home *** CD-ROM | disk | FTP | other *** search
/ Giga Games 1 / Giga Games.iso / net / go / prog / igc070.sh < prev    next >
Encoding:
Linux/UNIX/POSIX Shell Script  |  1993-06-20  |  90.8 KB  |  4,399 lines
  1. #! /bin/sh
  2. # This is a shell archive, meaning:
  3. # 1. Remove everything above the #! /bin/sh line.
  4. # 2. Save the resulting text in a file.
  5. # 3. Execute the file with /bin/sh (not csh) to create:
  6. #    README
  7. #    socket.c
  8. #    igc.c
  9. #    parse.c
  10. #    ascii.c
  11. #    board.c
  12. #    numbers.h
  13. #    igc.h
  14. #    Makefile
  15. #    igc.6
  16. #    BUGS
  17. # This archive created: Mon Jun  7 19:44:51 1993
  18. export PATH; PATH=/bin:/usr/bin:$PATH
  19. if test -f 'README'
  20. then
  21.     echo shar: "will not over-write existing file 'README'"
  22. else
  23. cat << \SHAR_EOF > 'README'
  24.         IGS - Ascii Client by Adrian Mariano
  25.                 adrian@u.washington.edu
  26.                            adrian on igs
  27.  
  28.  
  29. This is an ascii client program for the Internet Go Server.
  30.  
  31. Its purpose is to provide a useable interface to the server with
  32. ASCII character drawn Go boards.
  33.  
  34. This program requires UNIX with sockets capability. 
  35.  
  36. Read the Makefile for instructions on compiling.
  37.  
  38. SHAR_EOF
  39. fi
  40. if test -f 'socket.c'
  41. then
  42.     echo shar: "will not over-write existing file 'socket.c'"
  43. else
  44. cat << \SHAR_EOF > 'socket.c'
  45. #include <sys/types.h>
  46. #include <sys/time.h>
  47. #include <sys/socket.h>
  48. #include <netdb.h>
  49.  
  50. #ifndef WINS            /* Usually want this... */
  51. #include <netinet/in.h>
  52. #else                /* ... but need these for WINS. */
  53. #include <sys/in.h>
  54. #include <sys/inet.h>
  55. #endif
  56.  
  57. #include <fcntl.h>
  58. #include <sys/errno.h>
  59. #include <stdio.h>
  60. #ifndef FD_ZERO
  61. #include <sys/select.h>
  62. #endif
  63. #include "igc.h"
  64.  
  65. /* For some odd systems, which don't put this in errno.h. */
  66.  
  67. extern int errno;
  68.  
  69. char servename[80];
  70. int serveport;
  71. int sock;
  72. char inbuf[1000];
  73. int inptr = 0;
  74. int doecho = 1;
  75.  
  76.  
  77. sethost(s)
  78. char *s;
  79. {
  80.    strcpy(servename, s);
  81. }
  82.  
  83.  
  84. setport(s)
  85. int s;
  86. {
  87.    serveport = s;
  88.  
  89. }
  90.  
  91. void close_connection()
  92. {
  93.    close(sock);
  94. }
  95.  
  96.  
  97. #ifdef DEBUG
  98. FILE *blah;
  99. #endif
  100.  
  101.  
  102. setecho(ec)
  103. int ec;
  104. {
  105.    doecho = ec;
  106. }
  107.  
  108.  
  109. int open_connection()
  110. {
  111.    struct sockaddr_in server;
  112.    struct hostent *hp;
  113.    int ipn;
  114.  
  115.    printf("Opening connection to %s %d\n", servename, serveport);
  116. #ifdef DEBUG
  117.    {
  118.       int d;
  119.       char n[444];
  120.       d = 0;
  121.       do {
  122.      sprintf(n, "dump%d.igc", d);
  123.      blah = fopen(n, "r");
  124.      if (!blah) {
  125.         blah = fopen(n, "w");
  126.         if (blah)
  127.            printf("Creating dump file %s\n", n);
  128.         break;
  129.      }
  130.      close(blah);
  131.      d++;
  132.      if (d > 9) {
  133.         printf("Too many dump files.  Delete dump files (dump?.igc)? ");
  134.         fgets(n, 443, stdin);
  135.         if (n[0] != 'Y' && n[0] != 'y')
  136.            exit(1);
  137.         for (d = 0; d < 10; d++) {
  138.            sprintf(n, "dump%d.igc", d);
  139.            unlink(n);
  140.         }
  141.         blah = fopen("dump0.igc", "w");
  142.         if (!blah) {
  143.            printf("File open error.  Cannot create dump file\n");
  144.            exit(1);
  145.         }
  146.         break;
  147.      }
  148.       } while (1);
  149.       if (!blah) {
  150.      printf("File open error.  Cannot create dump file.\n");
  151.      exit(1);
  152.       }
  153.    }
  154. #endif
  155.    if (sscanf(servename, "%d.%d.%d.%d", &ipn, &ipn, &ipn, &ipn) == 4)
  156.       server.sin_addr.s_addr = inet_addr(servename);
  157.    else {
  158.       hp = gethostbyname(servename);
  159.       if (hp == 0) {
  160.      puts("Unknown host");
  161.      return -1;
  162.       }
  163.       bcopy(hp->h_addr, &server.sin_addr, hp->h_length);
  164.    }
  165.    server.sin_family = AF_INET;
  166.    server.sin_port = htons(serveport);
  167.    sock = socket(AF_INET, SOCK_STREAM, 0);
  168.    if (sock < 0) {
  169.       perror("socket");
  170.       return -1;
  171.    }
  172.    if (connect(sock, (struct sockaddr *) & server,
  173.            sizeof(struct sockaddr_in)) < 0) {
  174.       perror("connect");
  175.       return -1;
  176.    }
  177.    return 0;
  178. }
  179.  
  180.  
  181.  
  182. sendstr(buf)
  183. char *buf;
  184. {
  185.  
  186. #ifdef DEBUG
  187.    if (doecho && strlen(buf) && blah && buf[0] != '\377')
  188.       fprintf(blah, ">%s<\n", buf);
  189. #endif
  190.    write(sock, buf, strlen(buf));
  191. }
  192.  
  193.  
  194. /* returns 1 if telnet processing ate the character. */
  195.  
  196. #define IAC '\377'
  197. #define DONT '\376'
  198. #define DO '\375'
  199. #define WONT '\374'
  200. #define WILL '\373'
  201. #define AYT '\366'
  202. #define TELOPT_SGA  '\3'
  203. #define TELOPT_ECHO '\1'
  204.  
  205. int dotelnet(ch)
  206. char ch;
  207. {
  208.    static int telcount = 0;
  209.    static char telchars[4];
  210.  
  211.    if (ch == IAC || telcount == 1) {
  212.       telchars[telcount] = ch;
  213.       telcount++;
  214.       if (telcount == 2 && telchars[1] == AYT) {
  215.      telcount = 0;
  216.      sendstr("igc-yes\n");
  217.      return 0;
  218.       }
  219.       return 1;
  220.    }
  221.    if (telcount == 2) {
  222.       telcount = 0;
  223.       telchars[2] = ch;
  224.       telchars[3] = 0;
  225.       if (telchars[2] == TELOPT_ECHO) {
  226.      setecho(telchars[1] == WONT);
  227.      return 1;
  228.       }
  229.       if (telchars[1] == WILL) {
  230.      if (telchars[2] == TELOPT_SGA)
  231.         telchars[1] = DO;
  232.      else
  233.         telchars[1] = DONT;
  234.       } else if (telchars[1] == DO) {
  235.      if (telchars[2] == TELOPT_SGA)
  236.         telchars[1] = WILL;
  237.      else
  238.         telchars[1] = WONT;
  239.       }
  240.       sendstr(telchars);
  241.       return 1;
  242.    }
  243.    return 0;
  244. }
  245.  
  246.  
  247.  
  248.  
  249. int handlechar(retbuf, in)
  250. char *retbuf;
  251. char in;
  252. {
  253.    if (in == '\r')
  254.       return 0;
  255. #ifdef DEBUG
  256.    fputc(in, blah);
  257. #endif
  258.    if (dotelnet(in))
  259.       return 0;
  260.    if (in == '\n') {
  261.       inbuf[inptr] = 0;
  262.       strcpy(retbuf, inbuf);
  263.       inptr = 0;
  264.       return 1;
  265.    } else {
  266.       inbuf[inptr++] = in;
  267.       if (doneline(inbuf, inptr)) {
  268.      inbuf[inptr] = 0;
  269.      strcpy(retbuf, inbuf);
  270.      inptr = 0;
  271.      return 1;
  272.       }
  273.    }
  274.    return 0;
  275. }
  276.  
  277.  
  278.  
  279. int bufdata = 0, bufptr = 0;
  280. char thebuf[1000];
  281.  
  282. int pollserver(retbuf, checkstdin)
  283. char *retbuf;
  284. int checkstdin;
  285. {
  286.    int sel;
  287.    fd_set readers;
  288.  
  289.    FD_ZERO(&readers);
  290.    while (1) {
  291.       while (bufdata) {
  292.      bufdata--;
  293.      if (handlechar(retbuf, thebuf[bufptr++]))
  294.         return 1;
  295.       }
  296.       bufptr = 0;
  297.       if (checkstdin)
  298.      FD_SET(0, &readers);    /* Check stdin */
  299.       FD_SET(sock, &readers);
  300.       sel = select(sock + 1, &readers, NULL, NULL, (struct timeval *) 0);
  301.       if (sel == -1) {
  302.      if (errno != EINTR) {    /* ^Z will do this */
  303.         perror("select");
  304.         return -1;
  305.      }
  306.      continue;
  307.       }
  308.       if (FD_ISSET(sock, &readers)) {
  309.      bufdata = read(sock, thebuf, 1000);
  310.      if (!bufdata)
  311.         return -1;
  312.      if (bufdata < 0) {
  313.         perror("read");
  314.         return -2;
  315.      }
  316.       } else if (FD_ISSET(0, &readers))
  317.      return KEY;
  318.    }
  319. }
  320. SHAR_EOF
  321. fi
  322. if test -f 'igc.c'
  323. then
  324.     echo shar: "will not over-write existing file 'igc.c'"
  325. else
  326. cat << \SHAR_EOF > 'igc.c'
  327. #include "igc.h"
  328. #include <stdio.h>
  329. #include <string.h>
  330. #include <signal.h>
  331. #include <pwd.h>
  332. #include "numbers.h"
  333.  
  334.  
  335. #define RCNAME "/.igcrc"
  336.  
  337.  
  338. #define ATRC 1
  339. #define NOTATRC 2
  340. #define BOTH (ATRC | NOTATRC)
  341.  
  342. char login[20] = "";
  343. char password[20] = "";
  344.  
  345. char friend[MAXFRIENDS][MAXNAME];    /* friends list */
  346. int nfriends = 0;
  347.  
  348. message mesg;            /* structure for getting parsed info from
  349.                  * server */
  350.  
  351. char prefix[21];        /* Text prefix for each outgoing line */
  352. int xcur = -1, ycur = -1;    /* Cursor locations on board */
  353. int boardon = 0;        /* Is the board being displayed? */
  354. int boardmode = 0;        /* Are we on the board? */
  355. int beepcount = 1;        /* Number of beeps to send */
  356. int saybeep = 0;        /* Beep on say strings? */
  357. int tellbeep = 0;        /* Beep on tell strings? */
  358. int friendfilter = 0;        /* Filter login messages for friends? */
  359. int displayintro = 1;           /* Display intro before log in */
  360.  
  361. int ingame = -1;        /* Game which is displayed, -1 for none */
  362. int observing = 0;        /* Are we observing a game? */
  363. int justpeeked = 0;        /* Fixup flag for game number after peek */
  364. int needrestore = 0;        /* Need to restore board? (After status) */
  365. int bschange = 0;        /* boardsize changed?  Used with needrestore */
  366. extern int boardsize;
  367.  
  368. char local[1000], *loc;        /* Buffer for characters typed by local user */
  369.  
  370. struct {
  371.    char white[21], wrank[10], black[21], brank[10];
  372.    int hcap;
  373.    float komi;
  374.    int bbyo, wbyo, wtime, btime;
  375. }  curgame;            /* Information about current game */
  376.  
  377.  
  378. int (*whosort) ();
  379. int (*gamessort) ();
  380.  
  381. #define MAXSITES 10
  382.  
  383. struct {
  384.    char name[50];
  385.    char site[100];
  386.    int port;
  387. }  sitetable[MAXSITES] =
  388. {
  389.    { "hellspark", "hellspark.wharton.upenn.edu", 6969 },
  390.    { "pasteur", "ftp.pasteur.fr", 6969 },
  391.    { "", "", 6969 },
  392.    { "", "", 6969 },
  393.    { "", "", 6969 },
  394.    { "", "", 6969 },
  395.    { "", "", 6969 },
  396.    { "", "", 6969 },
  397.    { "", "", 6969 },
  398.    { "", "", 6969 }
  399. };
  400.  
  401.  
  402. void myexit(ex)
  403. int ex;
  404. {
  405.    if (boardon)
  406.       endAscii();
  407.    exit(ex);
  408. }
  409.  
  410.  
  411. void handleterm()
  412. {
  413.    close_connection();
  414.    myexit(0);
  415. }
  416.  
  417.  
  418. char *getpassword(repeat)
  419. int repeat;
  420. {  
  421. char trash[20];
  422.    if (repeat || !strlen(password)) {
  423.       printf("Password: ");
  424.       for (;;) {
  425.      fgets(password,20,stdin);
  426.      if (feof(stdin)) handleterm();
  427.          if (password[strlen(password)-1]!='\n'){
  428.    password[strlen(password)-1]='\n';
  429.            do{ 
  430.          fgets(trash,20,stdin);
  431.        }while (trash[strlen(trash)-1]!='\n');
  432.  }
  433.      if (strstr(password, "helpigc"))
  434.         printf("You are entering your password for the Internet Go Server.  You will be\nprompted twice for your password if you are creating a new account.  Enter\nthe same password twice in this case.\nPassword: ");
  435.      else if (!strlen(password))
  436.         printf("Empty password not allowed.\nPassword: ");
  437.      else
  438.         break;
  439.       }
  440.    }
  441.    return password;
  442. }
  443.  
  444.  
  445. char *getloginname(repeat)
  446. int repeat;
  447. { 
  448.    char trash[20];
  449.    if (repeat == 1)
  450.       printf("Login failed.\n");
  451.    if (repeat || !strlen(login)) {
  452.       printf("Login: ");
  453.       for (;;) {
  454.      fgets(login,20,stdin);
  455.      if (feof(stdin)) handleterm();
  456.          if (login[strlen(login)-1]!='\n'){
  457.            login[strlen(login)-1]='\n';
  458.            do{
  459.          fgets(trash,20,stdin);
  460.        }while (trash[strlen(trash)-1]!='\n');
  461.      }
  462.      if (strstr(login, "helpigc"))
  463.         printf("You are logging into the Internet Go server.  Type a login name now.\nLogin: ");
  464.      else if (!strlen(login))
  465.         printf("Blank names not allowed.\nLogin: ");
  466.      else
  467.         break;
  468.       }
  469.    } else
  470.       printf("Logging on as %s", login);
  471.    return login;
  472. }
  473.  
  474.  
  475.  
  476. putstr(s)
  477. char *s;
  478. {
  479.    if (boardon) {
  480.       addstring(s);
  481.       addchar('\n');
  482.    } else
  483.       puts(s);
  484. }
  485.  
  486.  
  487. dobeep()
  488. {
  489.    char ch;
  490.    for (ch = beepcount; ch--;)
  491.       putchar(7);
  492. }
  493.  
  494.  
  495. readrc()
  496. {
  497.    struct passwd *pw;
  498.    char rcfilename[1000];
  499.    FILE *rcfile;
  500.    char *var, *val, line[100], saveline[100];
  501.  
  502.    pw = getpwuid(geteuid());
  503.    strcpy(rcfilename, pw->pw_dir);
  504.    strcat(rcfilename, RCNAME);
  505.    if (rcfile = fopen(rcfilename, "rt")) {
  506.       while (fgets(line, 99, rcfile)) {
  507.      if (*line == '#')
  508.         continue;
  509.      strcpy(saveline, line);
  510.      if (!process(line, 0, ATRC)) {
  511.         if (saveline[strlen(saveline) - 1] == '\n')
  512.            saveline[strlen(saveline) - 1] = 0;
  513.         printf("%%Unknown command '%s' in .igcrc file\n", saveline);
  514.      }
  515.       }
  516.    }
  517. }
  518.  
  519.  
  520.  
  521. void dopassword(first)
  522. char *first;
  523. {
  524.    strncpy(password, first, 18);
  525.    strcat(password, "\n");
  526.    password[20]=0;
  527. }
  528.  
  529.  
  530. void dologin(first)
  531. char *first;
  532. {
  533.    strncpy(login, first, 18);
  534.    strcat(login, "\n");
  535.    login[20]=0;
  536. }
  537.  
  538.  
  539.  
  540. void handletstp()
  541. {
  542.    signal(SIGTSTP, handletstp);
  543.    if (boardon)
  544.       suspend();
  545.    kill(getpid(), SIGSTOP);
  546.    if (boardon) {
  547.       unsuspend();
  548.       if (boardmode)
  549.      boardrefresh();
  550.       else
  551.      serverrefresh();
  552.    }
  553. }
  554.  
  555.  
  556. int startgame(n)
  557. int n;
  558. {
  559.    char str[100], str2[30];
  560.    int ret, gotmove;
  561.  
  562.    gotmove = 0;
  563.  
  564.    sprintf(str, "games %d\n", n);
  565.    sendstr(str);
  566.    do {
  567.       do {
  568.      ret = getmessage(&mesg, 0);
  569.      if (ret < 0)
  570.         handleterm();
  571.       }
  572.       while (!ret);
  573.       if (mesg.id == MOVE) {
  574.      if (mesg.movecount)
  575.         putstr("%Premature move.  Restart game.");
  576.      else
  577.         gotmove = 1;
  578.       }
  579.    }
  580.    while (mesg.id != GAMES);
  581.    if (mesg.gamecount != 1 || mesg.gamelist[0].gnum != n)
  582.       return -1;
  583.    if (mesg.gamelist[0].bsize > 19) {
  584.       putstr("%Boardsize too large");
  585.       return -1;
  586.    }
  587.    strcpy(curgame.white, mesg.gamelist[0].white);
  588.    strcpy(curgame.black, mesg.gamelist[0].black);
  589.    strcpy(curgame.brank, mesg.gamelist[0].brank);
  590.    strcpy(curgame.wrank, mesg.gamelist[0].wrank);
  591.    curgame.hcap = mesg.gamelist[0].hcap;
  592.    curgame.komi = mesg.gamelist[0].komi;
  593.    if (observing) {
  594.       addstring("Removing observe\n");
  595.       sprintf(str, "observe %d\n", ingame);
  596.       sendstr(str);
  597.       do {
  598.      do {
  599.         ret = getmessage(&mesg, 0);
  600.         if (ret < 0)
  601.            handleterm();
  602.      }
  603.      while (!ret);
  604.       }
  605.       while (mesg.id != PROMPT);
  606.       observing = 0;
  607.    }
  608.    ingame = n;
  609.    needrestore = 0;
  610.    initboard(mesg.gamelist[0].bsize);
  611.    displaygamenumber(ingame);
  612.    xcur = ycur = mesg.gamelist[0].bsize / 2;
  613.    sprintf(str, "%s (%s)", curgame.black, curgame.brank);
  614.    sprintf(str2, "%s (%s)", curgame.white, curgame.wrank);
  615.    boardtitle(str, str2);
  616.    if (gotmove)
  617.       highlight(0, 0, 0, 0, mesg.btime, mesg.bbyo, mesg.wtime, mesg.wbyo);
  618.    showkomi(curgame.komi);
  619.    boardon = 1;
  620.    return 0;
  621. }
  622.  
  623.  
  624. getmoves(n)
  625. int n;
  626. {
  627.    char str[20];
  628.  
  629.    sprintf(str, "moves %d\n", n);
  630.    sendstr(str);
  631. }
  632.  
  633.  
  634. unobserve()
  635. {
  636.    sendstr("unobserve\n");
  637.    /* char str[20]; sprintf(str, "observe %d\n", ingame); sendstr(str); */
  638. }
  639.  
  640.  
  641. int observegame(n)
  642. int n;
  643. {
  644.    int ret;
  645.    char str[20];
  646.    if (n < 0)
  647.       return 1;
  648.    if (startgame(n))
  649.       return 1;
  650.    sprintf(str, "observe %d\n", n);
  651.    sendstr(str);
  652.    observing = 1;
  653.    do {
  654.       do {
  655.      ret = getmessage(&mesg, 0);
  656.      if (ret < 0)
  657.         handleterm();
  658.       }
  659.       while (!ret);
  660.       if ((mesg.id == INFO) && !strncmp(mesg.text, "Removing", 8))
  661.      putstr("%fatal sync error.  Restart igc.");
  662.    }
  663.    while (mesg.id != MOVE && mesg.id != UNDO);
  664.    getmoves(n);
  665.    return 0;
  666. }
  667.  
  668.  
  669. int peekgame(n)
  670. int n;
  671. {
  672.    /* if (!observing && ingame != -1) { putstr("Can't peek while playing.");
  673.     * return 1; } */
  674.    if (startgame(n))
  675.       return 1;
  676.    getmoves(n);
  677.    justpeeked = 1;
  678.    setgame(-1);
  679.    return 0;
  680. }
  681.  
  682. setgame(newgame)
  683. int newgame;
  684. {
  685.    if (newgame != ingame) {
  686.       ingame = newgame;
  687.       displaygamenumber(ingame);
  688.    }
  689. }
  690.  
  691. loadgame(name)
  692. char *name;
  693. {
  694.    char str[100];
  695.    int ret;
  696.    sprintf(str, "load %s\n", name);
  697.    sendstr(str);
  698.    do {
  699.       ret = getmessage(&mesg, 0);
  700.       if (ret < 0)
  701.      handleterm();
  702.    } while ((!ret) ||
  703.         (mesg.id != MOVE && mesg.id != ERROR && mesg.id != PROMPT));
  704.    if (mesg.id == ERROR)
  705.       putstr(mesg.text);
  706.    else if (mesg.id == PROMPT)
  707.       putstr("%Load error.");
  708.    else {
  709.       if (!startgame(mesg.gamenum))
  710.      getmoves(mesg.gamenum);
  711.    }
  712. }
  713.  
  714. char *helpmsg = "                   Server Window\n\
  715. unobserve      Stops observing.\n\
  716. peek <n>       Looks at the board for game n\n\
  717. restore        Restores active game (after look or status)\n\
  718. noboard        Goes back to full screen mode\n\
  719. clear          Clears the window on the right side of the screen\n\
  720. [no]inverse    Switches board to/from inverse \n\
  721. [no]invedge    Turns on/off inversed edges\n\
  722. [no]piecemarks Turns on/off piece marks\n\
  723. [no]edgemarks  Turns on/off edge marks\n\
  724. sort {none|rank|rating|game|name|idle} Chooses sorting order for who command\n\
  725. gamessort {none|number|obcount} Chooses sorting order for games command\n\
  726. user <name>    Checks output from last who for <name>\n\
  727. chars <list>   Sets board characters in client\n\
  728. border <char>  Sets the border character\n\
  729. beeps <n>      Sets number of beeps to use\n\
  730. [no]saybeep    Turns on/off beeps when a say is received\n\
  731. [no]tellbeep   Turns on/off beeps when a tell is received\n\
  732. goto <n>       Goes to a particular move in the current game.\n\
  733. [no]filter     Turn filtering of shouts on/off\n\
  734. [un]friend     Add or remove a name from the friends list\n\
  735. prefix         Sets prefix for all outgoing text you type\n\
  736.                Start commands with '!' to avoid using the prefix\n\
  737. \n\
  738. ESC switches between windows         ^L  refreshes the screen\n\
  739. \n\
  740.                    Board Window\n\
  741. Use number keys (12346789), emacs keys (^P ^N ^F ^B) or rogue keys\n\
  742.    (hjklbnyu) to move the cursor.\n\
  743. Press '0', return, or space to move (send position of cursor)\n\
  744. Press '.' or '>' to move forward through game, ',' or '<' to move backwards.\n\
  745.   '.' and ',' move by single moves.  '>' and '<' move by sets of ten moves.\n\
  746. Press 's' to go to start of game, 'e' to go to end.\n\
  747. Press 'f' or '/' to find the a particular move in a game by location.\n\
  748. Press 'c' to clear the current move mark.";
  749.  
  750.  
  751. void help()
  752. {
  753.    if (boardon)
  754.       bigmess(33, helpmsg);
  755.    else
  756.       puts(helpmsg);
  757. }
  758.  
  759.  
  760. doargs(argc, argv)
  761. int argc;
  762. char *argv[];
  763. {
  764.    int i;
  765.    for (i = 1; i < argc; i++) {
  766.       if (!strcmp(argv[i], "-s")) {
  767.      int j;
  768.      for (j = i; j < 3; j++)
  769.         argv[j] = argv[j + 1];
  770.      strcpy(login, "");
  771.      strcpy(password, "");
  772.      argc--;
  773.      break;
  774.       }
  775.    }
  776.    if (argc > 3) {
  777.       printf("Too many command line arguments\n\n");
  778.       exit(3);
  779.    }
  780.    if (argc > 1) {
  781.       for (i = 0; i < 10; i++)
  782.      if (!strcmp(argv[1], sitetable[i].name)) {
  783.         sethost(sitetable[i].site);
  784.         setport(sitetable[i].port);
  785.         if (argc > 2) {
  786.            printf("Error: port specified with named host.  Don't use a port number\n");
  787.            printf("when using the shorthand name for a host.\n\n");
  788.            exit(3);
  789.         }
  790.         return;
  791.      }
  792.       sethost(argv[1]);
  793.       if (argc > 2) {
  794.      if (atoi(argv[2]))
  795.         setport(atoi(argv[2]));
  796.      else {
  797.         printf("Illegal port specification\n\n");
  798.         exit(3);
  799.      }
  800.       }
  801.    }
  802. }
  803.  
  804.  
  805. weave()
  806. {
  807.    char *copy[MAXWHO];
  808.    int i, num;
  809.    num = mesg.whocount / 2 + (mesg.whocount & 1);
  810.    for (i = 0; i < num * 2; i++)
  811.       copy[i] = mesg.who[i];
  812.    for (i = 0; i < num; i++) {
  813.       mesg.who[2 * i] = copy[i];
  814.       mesg.who[2 * i + 1] = copy[num + i];
  815.    }
  816. }
  817.  
  818.  
  819. #define NAMECOL 12
  820. #define IDLECOL 25
  821. #define RANKCOL 32
  822. #define RATECOL 33
  823. #define FLAGCOL 2
  824. #define GAMECOL 10
  825.  
  826.  
  827. int namesort(left, right)
  828. char *left, *right;
  829. {
  830.    return strncasecmp(*(char **) left + NAMECOL, *(char **) right + NAMECOL, 11);
  831. }
  832.  
  833.  
  834. int gamesort(left, right)
  835. char *left, *right;
  836. {
  837.    int i;
  838.    char *a, *b;
  839.    a = *(char **) left;
  840.    b = *(char **) right;
  841.    if (a[GAMECOL] != '-' && b[GAMECOL] != '-') {
  842.       i = strncmp(a + GAMECOL - 2, b + GAMECOL - 2, 3);
  843.       return i ? i : namesort(left, right);
  844.    }
  845.    if (a[GAMECOL] != '-')
  846.       return -1;
  847.    if (b[GAMECOL] != '-')
  848.       return 1;
  849.    if (a[FLAGCOL] != b[FLAGCOL]) {
  850.       if (a[FLAGCOL] == 'X')
  851.      return -1;
  852.       if (b[FLAGCOL] == 'X')
  853.      return 1;
  854.       if (a[FLAGCOL] == '!')
  855.      return 1;
  856.       if (b[FLAGCOL] == '!')
  857.      return -1;
  858.    }
  859.    return ranksort(left, right);
  860. }
  861.  
  862.  
  863. int ratingsort(left, right)
  864. char *left, *right;
  865. {
  866.    char *a, *b;
  867.    a = *(char **) left;
  868.    b = *(char **) right;
  869.    if (a[RATECOL] == b[RATECOL])
  870.       return ranksort(left, right);
  871.    if (a[RATECOL] == '*')
  872.       return -1;
  873.    return 1;
  874. }
  875.  
  876.  
  877. int ranksort(left, right)
  878. char *left, *right;
  879. {
  880.    int i;
  881.    char *a, *b;
  882.  
  883.    a = *(char **) left;
  884.    b = *(char **) right;
  885.  
  886.    if (a[RANKCOL] == '2')
  887.       return -1;
  888.    if (b[RANKCOL] == '2')
  889.       return 1;
  890.    if (a[RANKCOL] != b[RANKCOL]) {
  891.       if (a[RANKCOL] == '?')
  892.      return 1;
  893.       if (b[RANKCOL] == '?')
  894.      return -1;
  895.       if (a[RANKCOL] == 'R')
  896.      return 1;
  897.       if (b[RANKCOL] == 'R')
  898.      return -1;
  899.       if (a[RANKCOL] == 'k')
  900.      return 1;
  901.       if (b[RANKCOL] == 'k')
  902.      return -1;
  903.       if (a[RANKCOL] == 'd')
  904.      return 1;
  905.       if (b[RANKCOL] == 'd')
  906.      return -1;
  907.       return namesort(a, b);
  908.    }
  909.    if (a[RANKCOL] == 'R' || a[RANKCOL] == '?')
  910.       return namesort(left, right);
  911.    i = atoi(a + RANKCOL - 2) - atoi(b + RANKCOL - 2);
  912.    if (a[RANKCOL] == 'k')
  913.       i = -i;
  914.    return i ? -i : namesort(left, right);
  915. }
  916.  
  917.  
  918. /*******************
  919.  * idlesort  decides whether a or b has been idle longer
  920.  *******************/
  921.  
  922. int idlesort(left, right)
  923. char *left, *right;
  924. {
  925.    int i;
  926.    char *a, *b;
  927.  
  928.    a = *(char **) left;
  929.    b = *(char **) right;
  930.  
  931.    /* first check the units letter (h,m,s) assume that we don't need to worry
  932.     * about d. */
  933.    if (a[IDLECOL] != b[IDLECOL]) {
  934.       if (a[IDLECOL] == 'h')
  935.      return -1;
  936.       if (b[IDLECOL] == 'h')
  937.      return 1;
  938.       if (a[IDLECOL] == 'm')
  939.      return -1;
  940.       if (b[IDLECOL] == 'm')
  941.      return 1;
  942.    }
  943.    i = atoi(b + IDLECOL - 2) - atoi(a + IDLECOL - 2);
  944.    return i ? i : namesort(left, right);
  945. }
  946.  
  947.  
  948. int gamenumsort(a, b)
  949. struct gametype *a;
  950. struct gametype *b;
  951. {
  952.    if (a->gnum < b->gnum)
  953.       return -1;
  954.    if (a->gnum > b->gnum)
  955.       return 1;
  956.    return 0;
  957. }
  958.  
  959. int gamesobsort(a, b)
  960. struct gametype *a;
  961. struct gametype *b;
  962. {
  963.    if (a->obcount > b->obcount)
  964.       return -1;
  965.    if (a->obcount < b->obcount)
  966.       return 1;
  967.    return 0;
  968. }
  969.  
  970.  
  971.  
  972. int choosegamessort(first)
  973. char *first;
  974. {
  975.    if (!first)
  976.       return 1;
  977.    if (!strcmp(first, "number")) {
  978.       gamessort = gamenumsort;
  979.       return 0;
  980.    }
  981.    if (!strcmp(first, "none")) {
  982.       gamessort = NULL;
  983.       return 0;
  984.    }
  985.    if (!strcmp(first, "obcount")) {
  986.       gamessort = gamesobsort;
  987.       return 0;
  988.    }
  989.    return 1;
  990. }
  991.  
  992.  
  993. int choosesort(first)
  994. char *first;
  995. {
  996.    if (!first)
  997.       return 1;
  998.    if (!strcmp(first, "name")) {
  999.       whosort = namesort;
  1000.       return 0;
  1001.    }
  1002.    if (!strcmp(first, "rank")) {
  1003.       whosort = ranksort;
  1004.       return 0;
  1005.    }
  1006.    if (!strcmp(first, "game")) {
  1007.       whosort = gamesort;
  1008.       return 0;
  1009.    }
  1010.    if (!strcmp(first, "none")) {
  1011.       whosort = 0;
  1012.       return 0;
  1013.    }
  1014.    if (!strcmp(first, "idle")) {
  1015.       whosort = idlesort;
  1016.       return 0;
  1017.    }
  1018.    if (!strcmp(first, "rating")) {
  1019.       whosort = ratingsort;
  1020.       return 0;
  1021.    }
  1022.    return 1;
  1023. }
  1024.  
  1025.  
  1026. restoregame()
  1027. {
  1028.    char str[30], str2[30];
  1029.  
  1030.    if (needrestore) {
  1031.       if (bschange)
  1032.      initboard(bschange);
  1033.       restoremaxmoves();
  1034.       endgame();
  1035.       needrestore = 0;
  1036.       sprintf(str, "%s (%s)", curgame.black, curgame.brank);
  1037.       sprintf(str2, "%s (%s)", curgame.white, curgame.wrank);
  1038.       boardtitle(str, str2);
  1039.       highlight(0, 0, 0, -1, curgame.btime, curgame.bbyo,
  1040.         curgame.wtime, curgame.wbyo);
  1041.       displaygamenumber(ingame);
  1042.    }
  1043. }
  1044.  
  1045.  
  1046. void dofilter(first)
  1047. int first;
  1048. {
  1049.    friendfilter = first;
  1050. }
  1051.  
  1052.  
  1053.  
  1054. void dofriend(who)
  1055. char *who;
  1056. {
  1057.    int i;
  1058.    char buff[60];
  1059.  
  1060.    if (!who) {
  1061.       putstr("%Current list of friends:\n");
  1062.       for (i = 0; i < nfriends; i++)
  1063.      putstr(friend[i]);
  1064.  
  1065.    } else {
  1066.       if (nfriends >= MAXFRIENDS)
  1067.      putstr("%Friend list is full.");
  1068.       else if (-1 != find_friend(who)) {
  1069.      sprintf(buff, "%%Player %s already in friend list.", who);
  1070.      putstr(buff);
  1071.       } else {
  1072.      strcpy(friend[nfriends], who);
  1073.      nfriends++;
  1074.      sprintf(buff, "%%Friend %s added.", who);
  1075.      putstr(buff);
  1076.       }
  1077.    }
  1078. }
  1079.  
  1080.  
  1081. int isfriend(text)
  1082. char *text;
  1083. {
  1084.    int i, length;
  1085.  
  1086.    if (*text != '{')
  1087.       return 1;
  1088.    text++;
  1089.    for (i = 0; i < nfriends; i++) {
  1090.       length = strlen(friend[i]);
  1091.       if (!strncmp(friend[i], text, length) && text[length] == ' ')
  1092.      return 1;
  1093.    }
  1094.    return 0;
  1095. }
  1096.  
  1097.  
  1098.  
  1099. void dounfriend(who)
  1100. char *who;
  1101. {
  1102.    char i;
  1103.  
  1104.    if (!who)
  1105.       putstr("%unfriend requires 1 parameter.");
  1106.    else if (-1 != (i = find_friend(who))) {
  1107.       for (; i < nfriends; i++)
  1108.      strcpy(friend[i], friend[i + 1]);
  1109.       nfriends--;
  1110.       putstr("%Friend removed.");
  1111.    } else
  1112.       putstr("%Friend not in list.");
  1113. }
  1114.  
  1115.  
  1116. int find_friend(fr)
  1117. char *fr;
  1118. {
  1119.    char i;
  1120.  
  1121.    for (i = 0; i < nfriends && strcmp(friend[i], fr); i++);
  1122.    return i == nfriends ? -1 : i;
  1123. }
  1124.  
  1125.  
  1126. main(argc, argv)
  1127. int argc;
  1128. char *argv[];
  1129. {
  1130.    char ch;
  1131.    int ret;
  1132.    puts("\tigc - Ascii Client version 0.70 by Adrian Mariano");
  1133.    puts("   type 'helpigc' to get client help, 'help' for server help\n");
  1134.    strcpy(prefix, "");
  1135.    whosort = namesort;
  1136.    gamessort = gamenumsort;
  1137.    readrc();
  1138.    sethost(sitetable[0].site);
  1139.    setport(sitetable[0].port);
  1140.    doargs(argc, argv);
  1141.    loc = local;
  1142.    signal(SIGINT, handleterm);
  1143.    signal(SIGTERM, handleterm);
  1144.    signal(SIGHUP, handleterm);
  1145.    signal(SIGTSTP, handletstp);
  1146.    if (open_connection())
  1147.       handleterm();
  1148.    puts("Connection established.");
  1149.    mesg.whocount = 0;
  1150.    {
  1151.       char *whoptr;
  1152.       for (whoptr = &(mesg.whodata[0][0]), ret = 0; ret < MAXWHO; ret++, whoptr += 40)
  1153.      mesg.who[ret] = whoptr;
  1154.    }
  1155.    initparser();
  1156.    do {
  1157.       if (boardon)
  1158.      if (boardmode)
  1159.         boardrefresh();
  1160.      else
  1161.         serverrefresh();
  1162.       ret = getmessage(&mesg, 1);
  1163.       if (ret < 0 && ret != KEY) {
  1164.      if (boardon) {
  1165.         endAscii();
  1166.         boardon = 0;
  1167.      }
  1168.      puts("Connection closed by server.");
  1169.      myexit(0);
  1170.       }
  1171.       if (ret > 0)
  1172.      switch (mesg.id) {
  1173.         case TOOMANY:
  1174.            myexit(0);
  1175.            printf("Too many players.  Sorry.\n");
  1176.            break;
  1177.         case QUITMESG:
  1178.            if (boardon) {
  1179.           endAscii();
  1180.           boardon = 0;
  1181.            }
  1182.            puts(mesg.text);
  1183.            break;
  1184.         case ONSERVER:
  1185.            printf("\nWarning: Client mode is not set on the IGS.  Setting client mode now.\n         The message of the day was not displayed.  Type 'help motd' to see it.\n         You have not been informed if you have messages.\n\n");
  1186.  
  1187.            break;
  1188.         case BEEP:
  1189.            if (mesg.beep)
  1190.           dobeep();
  1191.            break;
  1192.         case MOVE:
  1193.            if (!boardon)
  1194.           puts("%Error: isolated move received");
  1195.            else {
  1196.           int i;
  1197.           restoregame();
  1198.           sethighlight(0);
  1199.           for (i = 0; i < mesg.movecount - 1; i++)
  1200.              makemove(mesg.moves[i].x, mesg.moves[i].y,
  1201.                   mesg.moves[i].movenum,
  1202.                   mesg.moves[i].color, mesg.btime,
  1203.                   mesg.bbyo, mesg.wtime, mesg.wbyo);
  1204.           sethighlight(1);
  1205.           if (mesg.movecount)
  1206.              makemove(mesg.moves[i].x, mesg.moves[i].y,
  1207.                   mesg.moves[i].movenum,
  1208.                   mesg.moves[i].color, mesg.btime,
  1209.                   mesg.bbyo, mesg.wtime, mesg.wbyo);
  1210.           curgame.bbyo = mesg.bbyo;
  1211.           curgame.btime = mesg.btime;
  1212.           curgame.wtime = mesg.wtime;
  1213.           curgame.wbyo = mesg.wbyo;
  1214.  
  1215.  
  1216.           setcursor(xcur, ycur);
  1217.           if (!justpeeked)
  1218.              setgame(mesg.gamenum);
  1219.           justpeeked = 0;
  1220.            }
  1221.            break;
  1222.         case UNDO:
  1223.            restoregame();
  1224.            if (!boardon)
  1225.           puts("%Error: isolated undo received");
  1226.            else {
  1227.           setgame(mesg.gamenum);
  1228.           undo();
  1229.           setcursor(xcur, ycur);
  1230.            }
  1231.            break;
  1232.         case SCOREUNDO:
  1233.            restoregame();
  1234.            if (endgame())
  1235.           putstr("%score undo error");
  1236.            else
  1237.           putstr("Scoring undone.");
  1238.            break;
  1239.         case LOAD:
  1240.            if (!startgame(mesg.gamenum))
  1241.           getmoves(mesg.gamenum);
  1242.            break;
  1243.         case MATCH:
  1244.            startgame(mesg.gamenum);
  1245.            break;
  1246.         case REMOVE:
  1247.            restoregame();
  1248.            removeGroup(mesg.x, mesg.y);
  1249.            setcursor(xcur, ycur);
  1250.            break;
  1251.         case SCORE:
  1252.            {
  1253.           char str[50];
  1254.           sprintf(str, "  %s (B): %g\n  %s (W): %g",
  1255.               mesg.black, mesg.bscore, mesg.white, mesg.wscore);
  1256.           putstr(str);
  1257.            }
  1258.            break;
  1259.         case STARTSCORE:
  1260.            putstr("Remove dead groups to score.");
  1261.            putstr(mesg.text);
  1262.            break;
  1263.         case STATUS:
  1264.         case LOOK:
  1265.            {
  1266.           int pris[2];
  1267.           char str[30], str2[30];
  1268.  
  1269.           if (mesg.boardsize > 19)
  1270.              putstr("%Boardsize too big.");
  1271.           else {
  1272.              needrestore = 1;
  1273.              bschange = 0;
  1274.              savemaxmoves();
  1275.              if (!boardon || boardsize != mesg.boardsize) {
  1276.             if (!boardon)
  1277.                needrestore = 0;
  1278.             else
  1279.                bschange = boardsize;
  1280.             initboard(mesg.boardsize);
  1281.             xcur = ycur = mesg.boardsize / 2;
  1282.             boardon = 1;
  1283.              }
  1284.              pris[0] = mesg.bcap;
  1285.              pris[1] = mesg.wcap;
  1286.              sprintf(str, "%s (%s)", mesg.black, mesg.brank);
  1287.              sprintf(str2, "%s (%s)", mesg.white, mesg.wrank);
  1288.              boardtitle(str, str2);
  1289.              highlight(0, 0, 0, -1, mesg.btime, mesg.bbyo,
  1290.                    mesg.wtime, mesg.wbyo);
  1291.              drawpris(pris);
  1292.              showboard(mesg.board);
  1293.              displaygamenumber(-2);
  1294.           }
  1295.            }
  1296.            break;
  1297.         case KIBITZ:
  1298.            {
  1299.           char s[300];
  1300.           sprintf(s, "%s: %s", mesg.kibitzer, mesg.kibitz);
  1301.           putstr(s);
  1302.            }
  1303.            break;
  1304.         case WHO:
  1305.            {
  1306.           char out[80 * MAXWHO];
  1307.           int i;
  1308.           if (whosort) {
  1309.              qsort(mesg.who, mesg.whocount, sizeof(char *), whosort);
  1310.              weave();
  1311.           }
  1312.           strcpy(out, mesg.whofirst);
  1313.           for (i = 0; i < mesg.whocount; i++) {
  1314.              strcat(out, i & 1 ? " | " : "\n");
  1315.              strcat(out, mesg.who[i]);
  1316.           }
  1317.           strcat(out, "\n");
  1318.           strcat(out, mesg.wholast);
  1319.           if (boardon)
  1320.              bigmess(mesg.lines, out);
  1321.           else
  1322.              putstr(out);
  1323.            }
  1324.            break;
  1325.         case GAMES:
  1326.            {
  1327.           char out[80 * MAXGAMES];
  1328.           int i;
  1329.           if (gamessort)
  1330.              qsort(mesg.gamelist, mesg.gamecount, sizeof(struct gametype), gamessort);
  1331.           strcpy(out, mesg.gamefirst);
  1332.           strcat(out, "\n");
  1333.           for (i = 0; i < mesg.gamecount; i++)
  1334.              strcat(out, mesg.gamelist[i].gametext);
  1335.           if (boardon)
  1336.              bigmess(mesg.gamecount + 1, out);
  1337.           else
  1338.              putstr(out);
  1339.            }
  1340.            break;
  1341.         case STORED:
  1342.            if (!strlen(mesg.text))
  1343.           putstr("No stored games");
  1344.            else
  1345.           putstr(mesg.text);
  1346.            break;
  1347.         case CHKOMI:
  1348.            curgame.komi = mesg.mykomi;
  1349.            showkomi(curgame.komi);
  1350.         case INFO:
  1351.            if (strstr(mesg.text, "Removing")) {
  1352.           observing = 0;
  1353.           setgame(-1);
  1354.           putstr(mesg.text);
  1355.            } else if (mesg.lines > 1 && boardon)
  1356.           bigmess(mesg.lines, mesg.text);
  1357.            else if (strlen(mesg.text))
  1358.           putstr(mesg.text);
  1359.            break;
  1360.         case PROMPT:
  1361.            if (ingame != -1 && mesg.prompttype == 5) {
  1362.           setgame(-1);
  1363.           observing = 0;
  1364.            }
  1365.            break;
  1366.             case ENDGAMEINFO:
  1367.                if (observing && mesg.gamenum == ingame){
  1368.                   setgame(-1);
  1369.                   observing = 0;
  1370.                }
  1371.                putstr(mesg.text);
  1372.            break;
  1373.             case ENDGAME:
  1374.                if (observing && mesg.gamenum == ingame){
  1375.           setgame(-1);
  1376.           observing = 0;
  1377.                }
  1378.         case SHOUT:
  1379.            if (!friendfilter || isfriend(mesg.text))
  1380.           putstr(mesg.text);
  1381.            break;
  1382.  
  1383.         case SAY:
  1384.            if (saybeep)
  1385.           dobeep();
  1386.            putstr(mesg.text);
  1387.            break;
  1388.         case TELL:
  1389.            if (tellbeep)
  1390.           dobeep();
  1391.            putstr(mesg.text);
  1392.            break;
  1393.         case 0:
  1394.            break;
  1395.             case INTRO:
  1396.                if (!displayintro) 
  1397.                   break;
  1398.         default:
  1399.            if (mesg.lines > 1 && boardon)
  1400.           bigmess(mesg.lines, mesg.text);
  1401.            else if (strlen(mesg.text))
  1402.           putstr(mesg.text);
  1403.            break;
  1404.      }
  1405.       if (ret == KEY) {
  1406.      ret = read(fileno(stdin), &ch, 1);
  1407.      if (ch == '\r')
  1408.         ch = '\n';
  1409.      if (ch == 'L' - 64 && boardon)
  1410.         redraw();
  1411.      else if (ch == 27 && boardon)
  1412.         switchmode();
  1413.      else if (boardmode)
  1414.         doboardmode(ch);
  1415.      else
  1416.         doservermode(ch);
  1417.       }
  1418.    }
  1419.    while (1);
  1420.    handleterm();
  1421. }
  1422.  
  1423.  
  1424. switchmode()
  1425. {
  1426.    boardmode = !boardmode;
  1427.    if (boardmode)
  1428.       setcursor(xcur, ycur);
  1429. }
  1430.  
  1431.  
  1432. static char *nomoves = "%no moves recorded";
  1433.  
  1434. doboardmode(ch)
  1435. char ch;
  1436. {
  1437.    char movestr[10];
  1438.    switch (ch) {
  1439.       case '^':
  1440.      switchmode();
  1441.      clearserver();
  1442.      switchmode();
  1443.      break;
  1444.       case ',':
  1445.      restoregame();
  1446.      if (backward(1))
  1447.         putstr(nomoves);
  1448.      break;
  1449.       case '.':
  1450.      restoregame();
  1451.      if (forward(1))
  1452.         putstr(nomoves);
  1453.      break;
  1454.       case '<':
  1455.      restoregame();
  1456.      if (backward(10))
  1457.         putstr(nomoves);
  1458.      break;
  1459.       case '>':
  1460.      restoregame();
  1461.      if (forward(10))
  1462.         putstr(nomoves);
  1463.      break;
  1464.       case 's':
  1465.      restoregame();
  1466.      if (beginninggame())
  1467.         putstr(nomoves);
  1468.      break;
  1469.       case 'e':
  1470.      restoregame();
  1471.      if (endgame())
  1472.         putstr(nomoves);
  1473.      break;
  1474.       case 'f':
  1475.       case '/':
  1476.      restoregame();
  1477.      if (search(xcur, ycur))
  1478.         putstr("%No move found at that point");
  1479.      break;
  1480.  
  1481.       case '1':
  1482.       case 'b':
  1483.      if (++ycur == boardsize)
  1484.         ycur = 0;
  1485.      if (!xcur--)
  1486.         xcur = boardsize - 1;
  1487.      break;
  1488.       case '3':
  1489.       case 'n':
  1490.      if (++ycur == boardsize)
  1491.         ycur = 0;
  1492.      if (++xcur == boardsize)
  1493.         xcur = 0;
  1494.      break;
  1495.       case '7':
  1496.       case 'y':
  1497.      if (!xcur--)
  1498.         xcur = boardsize - 1;
  1499.      if (!ycur--)
  1500.         ycur = boardsize - 1;
  1501.      break;
  1502.       case '9':
  1503.       case 'u':
  1504.      if (!ycur--)
  1505.         ycur = boardsize - 1;
  1506.      if (++xcur == boardsize)
  1507.         xcur = 0;
  1508.      break;
  1509.       case 'B' - 64:
  1510.       case '4':
  1511.       case 'h':
  1512.  
  1513.      if (!xcur--)
  1514.         xcur = boardsize - 1;
  1515.      break;
  1516.       case 'P' - 64:
  1517.       case '8':
  1518.       case 'k':
  1519.      if (!ycur--)
  1520.         ycur = boardsize - 1;
  1521.      break;
  1522.       case 'N' - 64:
  1523.       case '2':
  1524.       case 'j':
  1525.      if (++ycur == boardsize)
  1526.         ycur = 0;
  1527.      break;
  1528.       case 'F' - 64:
  1529.       case '6':
  1530.       case 'l':
  1531.      if (++xcur == boardsize)
  1532.         xcur = 0;
  1533.      break;
  1534.       case 'c':
  1535.      unmark();
  1536.      break;
  1537.       case '\n':
  1538.       case '\r':
  1539.       case ' ':
  1540.       case '0':
  1541.      sprintf(movestr, "%c%d\n", xcur + 'A' + (xcur + 'A' >= 'I' ? 1 : 0),
  1542.          boardsize - ycur);
  1543.      sendstr(movestr);
  1544.      break;
  1545.    }
  1546.    setcursor(xcur, ycur);
  1547. }
  1548.  
  1549.  
  1550. void dopeek(first)
  1551. char *first;
  1552. {
  1553.    if (first) {
  1554.       if (!observing && ingame != -1)
  1555.      putstr("%Can't observe while playing");
  1556.       else if (observing && ingame == atoi(first))
  1557.      unobserve();
  1558.       else if (peekgame(atoi(first)))
  1559.      putstr("%No such game");
  1560.    }
  1561. }
  1562.  
  1563.  
  1564. void doobserve(first)
  1565. char *first;
  1566. {
  1567.    if (first) {
  1568.       if (!observing && ingame != -1)
  1569.      putstr("%Can't observe while playing");
  1570.       else if (observing && ingame == atoi(first))
  1571.      unobserve();
  1572.       else if (observegame(atoi(first)))
  1573.      putstr("%No such game");
  1574.    }
  1575. }
  1576.  
  1577.  
  1578. void dounobserve()
  1579. {
  1580.    if (observing)
  1581.       unobserve();
  1582.    else
  1583.       putstr("%Not observing");
  1584. }
  1585.  
  1586.  
  1587. void doload(first)
  1588. char *first;
  1589. {
  1590.    if (first)
  1591.       loadgame(first);
  1592. }
  1593.  
  1594.  
  1595. void dochars(first)
  1596. char *first;
  1597. {
  1598.    if (first) {
  1599.       setchars(first);
  1600.       if (boardon) {
  1601.      reinitboard(boardsize);
  1602.      endgame();
  1603.       }
  1604.    }
  1605. }
  1606.  
  1607.  
  1608. void dorestore(first)
  1609. char *first;
  1610. {
  1611.    if (!needrestore)
  1612.       putstr("%no game to restore");
  1613.    restoregame();
  1614. }
  1615.  
  1616.  
  1617. void dosort(first)
  1618. char *first;
  1619. {
  1620.    if (choosesort(first))
  1621.       putstr("%Unknown sorting method");
  1622. }
  1623.  
  1624.  
  1625. void dogamessort(first)
  1626. char *first;
  1627. {
  1628.    if (choosegamessort(first))
  1629.       putstr("%Unknown games sorting method");
  1630. }
  1631.  
  1632.  
  1633.  
  1634. void doborder(first)
  1635. char *first;
  1636. {
  1637.    if (!first)
  1638.       setborder(' ');
  1639.    else
  1640.       setborder(*first);
  1641.    if (boardon) {
  1642.       reinitboard(boardsize);
  1643.       endgame();
  1644.    }
  1645. }
  1646.  
  1647.  
  1648. void dointro(first)
  1649. int first;
  1650. {
  1651.    displayintro=first;
  1652. }
  1653.  
  1654.  
  1655. void doinverse(first)
  1656. int first;
  1657. {
  1658.    setinverse(first);
  1659.    if (boardon) {
  1660.       reinitboard(boardsize);
  1661.       endgame();
  1662.    }
  1663. }
  1664.  
  1665.  
  1666. void doedgemarks(first)
  1667. int first;
  1668. {
  1669.    setedgemark(first);
  1670.    if (boardon) {
  1671.       reinitboard(boardsize);
  1672.       endgame();
  1673.    }
  1674. }
  1675.  
  1676. void dopiecemarks(first)
  1677. int first;
  1678. {
  1679.    setpiecemark(first);
  1680.    if (boardon) {
  1681.       reinitboard(boardsize);
  1682.       endgame();
  1683.    }
  1684. }
  1685.  
  1686.  
  1687.  
  1688. void doinvedge(first)
  1689. int first;
  1690. {
  1691.    setinverseborder(first);
  1692.    if (boardon) {
  1693.       reinitboard(boardsize);
  1694.       endgame();
  1695.    }
  1696. }
  1697.  
  1698.  
  1699. void doprefix(first)
  1700. char *first;
  1701. {
  1702.    if (!first)
  1703.       strcpy(prefix, "");
  1704.    else {
  1705.       strncpy(prefix, first, 19);
  1706.       prefix[20] = 0;
  1707.    }
  1708.  
  1709.    if (boardon)
  1710.       showprefix(prefix);
  1711.    else
  1712.       printf("Prefix '%s'\n", prefix);
  1713. }
  1714.  
  1715. void douser(first)
  1716. char *first;
  1717. {
  1718.    int i, found;
  1719.  
  1720.    if (!first)
  1721.       putstr("%No user specified");
  1722.    else {
  1723.       found = 0;
  1724.       for (i = 0; i < mesg.whocount; i++) {
  1725.      if (!strncmp(mesg.who[i] + NAMECOL, first, strlen(first)) &&
  1726.          mesg.who[i][NAMECOL + strlen(first)] == ' ') {
  1727.         putstr(mesg.who[i]);
  1728.         found = 1;
  1729.      }
  1730.       }
  1731.       if (!found)
  1732.      putstr("%User not found in last who");
  1733.    }
  1734. }
  1735.  
  1736.  
  1737. void dosaybeep(first)
  1738. int first;
  1739. {
  1740.    saybeep = first;
  1741. }
  1742.  
  1743.  
  1744. void dotellbeep(first)
  1745. int first;
  1746. {
  1747.    tellbeep = first;
  1748. }
  1749.  
  1750.  
  1751. void dobeeps(first)
  1752. char *first;
  1753. {
  1754.    if (first)
  1755.       beepcount = atoi(first);
  1756. }
  1757.  
  1758. void doclear(first)
  1759. char *first;
  1760. {
  1761.    if (!boardon)
  1762.       putstr("%Cannot clear.");
  1763.    else
  1764.       clearserver();
  1765. }
  1766.  
  1767. void donoboard(first)
  1768. char *first;
  1769. {
  1770.    if (boardon) {
  1771.       if (ingame != -1) {
  1772.      putstr("Board in use.  Cannot remove.");
  1773.       } else {
  1774.      boardon = 0;
  1775.      boardmode = 0;
  1776.      endAscii();
  1777.       }
  1778.    } else
  1779.       putstr("%No board to remove.");
  1780. }
  1781.  
  1782.  
  1783. void dogoto(first)
  1784. char *first;
  1785. {
  1786.    if (boardon) {
  1787.       first = strtok(NULL, " \t");
  1788.       if (first)
  1789.      construct(atoi(first));
  1790.    } else
  1791.       putstr("%no board");
  1792. }
  1793.  
  1794.  
  1795. /* Warning:  This function makes calls to strtok which assume that we've
  1796.  * already started parsing the input line. */
  1797.  
  1798. void dosite(first)
  1799. char *first;
  1800. {
  1801.    int num;
  1802.    char *next;
  1803.  
  1804.    num = atoi(first);
  1805.    if (num < 0 || num >= MAXSITES) {
  1806.       printf("%%invalid site number: %d\n", num);
  1807.       return;
  1808.    }
  1809.    next = strtok(NULL, " \t\n=");
  1810.    if (!next) {
  1811.       printf("%%invalid or missing site name in 'site %d'\n", num);
  1812.       return;
  1813.    }
  1814.    strcpy(sitetable[num].name, next);
  1815.    next = strtok(NULL, " \t\n=");
  1816.    if (!next) {
  1817.       printf("%%invalid or missing host name in 'site %d' command\n", num);
  1818.       return;
  1819.    }
  1820.    strcpy(sitetable[num].site, next);
  1821.    next = strtok(NULL, " \t\n=");
  1822.    if (next && atoi(next))
  1823.       sitetable[num].port = atoi(next);
  1824. }
  1825.  
  1826.  
  1827.  
  1828. int notfirst = 0;
  1829.  
  1830. doservermode(ch)
  1831. char ch;
  1832. {
  1833.    *loc = ch;
  1834.    *(loc + 1) = 0;
  1835.    if (ch < ' ' && ch != ('U' - 64) && ch != '\b' && ch != '\n')
  1836.       return;
  1837.    if (boardon) {
  1838.       if (*loc == '\b' || *loc == '\177') {
  1839.      if (strlen(local) > 1) {
  1840.         deletechar(strlen(local) - 2);
  1841.         loc -= 2;
  1842.      } else
  1843.         loc--;
  1844.       } else if (*loc == 'U' - 64) {
  1845.      loc = local;
  1846.      clrline();
  1847.      return;
  1848.       } else if (strlen(local) >= linesize()) {
  1849.      if (!notfirst)
  1850.         sendstr(prefix);
  1851.      sendstr(local);
  1852.      loc = local;
  1853.      notfirst = 1;
  1854.      clrline();
  1855.      putstr(local);
  1856.      return;
  1857.       } else
  1858.      addcharline(strlen(local) - 1, *loc);
  1859.    }
  1860.    if (*loc == '\n') {
  1861.       loc++;
  1862.       *loc = 0;
  1863.       if (boardon) {
  1864.      addstring(local);
  1865.       }
  1866.       if (notfirst)
  1867.      sendstr(local);
  1868.       else if (local[0] == '!')
  1869.      process(local + 1, 0, NOTATRC);
  1870.       else if (strlen(prefix)) {
  1871.      sendstr(prefix);
  1872.      sendstr(local);
  1873.       } else
  1874.      process(local, 1, NOTATRC);
  1875.       if (boardon)
  1876.      clrline();
  1877.       notfirst = 0;
  1878.       loc = local;
  1879.    } else
  1880.       loc++;
  1881. }
  1882.  
  1883.  
  1884.  
  1885.  
  1886.  
  1887. struct commandtype {
  1888.    char *command;
  1889.    void (*action) ();
  1890.    int inrc;
  1891.    int toggle;
  1892. }  comlist[] =
  1893. {
  1894.    { "border", doborder, BOTH, 0 },
  1895.    { "chars", dochars, BOTH, 0 },
  1896.    { "clear", doclear, NOTATRC, 0 },
  1897.    { "beeps", dobeeps, BOTH, 0 },
  1898.    { "edgemarks", doedgemarks, BOTH, 1 },
  1899.    { "filter", dofilter, BOTH, 1}, 
  1900.    { "friend", dofriend, BOTH, 0 }, 
  1901.    { "gamessort", dogamessort, BOTH, 0 },
  1902.    { "goto", dogoto, NOTATRC, 0 },
  1903.    { "helpigc", help, NOTATRC, 0 },
  1904.    { "intro", dointro, BOTH, 1}, 
  1905.    { "invedge", doinvedge, BOTH, 1 },
  1906.    { "inverse", doinverse, BOTH, 1 },
  1907.    { "loa", doload, NOTATRC, 0 },
  1908.    { "load", doload, NOTATRC, 0 },
  1909.    { "login", dologin, ATRC, 0 },
  1910.    { "mo", dopeek, NOTATRC, 0 },
  1911.    { "mov", dopeek, NOTATRC, 0 },
  1912.    { "move", dopeek, NOTATRC, 0 },
  1913.    { "moves", dopeek, NOTATRC, 0 },
  1914.    { "noboard", donoboard, NOTATRC, 0 },
  1915.    { "ob", doobserve, NOTATRC, 0 },
  1916.    { "obs", doobserve, NOTATRC, 0 },
  1917.    { "obse", doobserve, NOTATRC, 0 },
  1918.    { "obser", doobserve, NOTATRC, 0 },
  1919.    { "observ", doobserve, NOTATRC, 0 },
  1920.    { "observe", doobserve, NOTATRC, 0 },
  1921.    { "password", dopassword, ATRC, 0 },
  1922.    { "peek", dopeek, NOTATRC, 0 },
  1923.    { "piecemarks", dopiecemarks, BOTH, 1 },
  1924.    { "prefix", doprefix, NOTATRC, 0 },
  1925.    { "restore", dorestore, NOTATRC, 0 },
  1926.    { "saybeep", dosaybeep, BOTH, 1 },
  1927.    { "site", dosite, ATRC, 0}, 
  1928.    { "sort", dosort, BOTH, 0 },
  1929.    { "tellbeep", dotellbeep, BOTH, 1 },
  1930.    { "unfriend", dounfriend, BOTH, 0 }, 
  1931.    { "unob", dounobserve, NOTATRC, 0 },
  1932.    { "unobserve", dounobserve, NOTATRC, 0 },
  1933.    { "user", douser, NOTATRC, 0 }
  1934. };
  1935.  
  1936.  
  1937. /* Returns 1 if the command was parsed locally.  Returns 0 if the command was
  1938.  * passed the the server, or not parsed locally. */
  1939.  
  1940. int process(comm, dopre, state)
  1941. char *comm;
  1942. int dopre;
  1943. int state;
  1944. {
  1945.    char *first, *second;
  1946.    char save[1000];
  1947.    int i;
  1948.  
  1949.    strcpy(save, comm);
  1950.    first = strtok(comm, " \n\t=");
  1951.    second = strtok(NULL, " \n\t=");
  1952.    if (!first)
  1953.       return 1;
  1954.    for (i = 0; i < sizeof(comlist) / sizeof(struct commandtype); i++) {
  1955.       if ((state & comlist[i].inrc) &&
  1956.       !strcmp(first, comlist[i].command)) {
  1957.      if (comlist[i].toggle)
  1958.         comlist[i].action(1);
  1959.      else
  1960.         comlist[i].action(second);
  1961.      return 1;
  1962.       }
  1963.    }
  1964.    if (!strncmp(first, "no", 2)) {
  1965.       first += 2;
  1966.       for (i = 0; i < sizeof(comlist) / sizeof(struct commandtype); i++) {
  1967.      if ((state & comlist[i].inrc) && comlist[i].toggle &&
  1968.          !strcmp(first, comlist[i].command)) {
  1969.         comlist[i].action(0);
  1970.         return 1;
  1971.      }
  1972.       }
  1973.    }
  1974.    if (state == NOTATRC) {
  1975.       if (dopre)
  1976.      sendstr(prefix);
  1977.       sendstr(save);
  1978.    }
  1979.    return 0;
  1980. }
  1981. SHAR_EOF
  1982. fi
  1983. if test -f 'parse.c'
  1984. then
  1985.     echo shar: "will not over-write existing file 'parse.c'"
  1986. else
  1987. cat << \SHAR_EOF > 'parse.c'
  1988. #include "igc.h"
  1989. #include <stdio.h>
  1990. #include <string.h>
  1991. #include <sys/types.h>
  1992. #include "numbers.h"
  1993.  
  1994. extern char *getloginname();
  1995. extern char *getpassword();
  1996. int loggedon, verbosetog;
  1997. int repeatpass, repeatlogin;
  1998.  
  1999. #ifdef STRSTR
  2000. char *strstr();
  2001. #endif
  2002.  
  2003. #ifdef STRTOL
  2004. long strtol();
  2005. #endif
  2006.  
  2007. char *Prompts[] =
  2008. {
  2009.    "Login: ",
  2010.    "Password: ",
  2011.    "Password: ",
  2012.    "Enter Your Password Again: ",
  2013.    "Enter your e-mail address (None): ",
  2014.    "#> ",
  2015.    "#> ",
  2016.    "Enter Dead Group: ",
  2017.    "#> ",
  2018.    "#> ",
  2019. };
  2020.  
  2021.  
  2022. initparser()
  2023. {
  2024.    loggedon = 0;
  2025.    repeatpass = 0;
  2026.    repeatlogin = 0;
  2027.    verbosetog = 0;
  2028. }
  2029.  
  2030.  
  2031. DoState(s)
  2032. char *s;
  2033. {
  2034.    if (strncmp(s, Prompts[LOGON], strlen(Prompts[LOGON])) == 0)
  2035.       return LOGON;
  2036.    if (strncmp(s, "1 1", 3) == 0)
  2037.       return PASSWORD;
  2038.    if (strncmp(s, "1 0", 3) == 0)
  2039.       return LOGON;
  2040.    if (strncmp(s, Prompts[PASSWORD], strlen(Prompts[PASSWORD])) == 0)
  2041.       return PASSWORD;
  2042.    if (strncmp(s, Prompts[PASSWD_NEW], strlen(Prompts[PASSWD_NEW])) == 0)
  2043.       return PASSWD_NEW;
  2044.    if (strncmp(s, Prompts[PASSWD_CONFIRM],
  2045.            strlen(Prompts[PASSWD_CONFIRM])) == 0)
  2046.       return PASSWD_CONFIRM;
  2047.    if (strncmp(s, Prompts[WAITING], strlen(Prompts[WAITING])) == 0)
  2048.       return WAITING;
  2049.    if (!strncmp(s, "Too many players, sorry", 23) ||
  2050.        !strncmp(s, "Sorry, the server is full", 24))
  2051.       return TOOMANY;
  2052.    return -1;
  2053. }
  2054.  
  2055. static long appending = 0;
  2056.  
  2057. int getmessage(mess, checkstdin)
  2058. message *mess;
  2059. int checkstdin;
  2060. {
  2061.    char mesg[2000];
  2062.    int ret;
  2063.    char *textpart;
  2064.  
  2065.    ret = pollserver(mesg, checkstdin);
  2066.    if (ret <= 0)
  2067.       return ret;
  2068.    switch (DoState(mesg)) {
  2069.       case PASSWD_NEW:
  2070.       case PASSWD_CONFIRM:
  2071.       case PASSWORD:
  2072.      sendstr(getpassword(repeatpass++));
  2073.      break;
  2074.       case WAITING:
  2075.      sendstr("toggle client true\n");
  2076.      mess->id = ONSERVER;
  2077.      loggedon = 1;
  2078.      return 1;
  2079.       case TOOMANY:
  2080.      mess->id = TOOMANY;
  2081.      return 1;
  2082.       case LOGON:
  2083.      {
  2084.         int needlogin;
  2085.         needlogin = 1;
  2086.         do {
  2087.            if (needlogin == 1) {
  2088.           sendstr(getloginname(repeatlogin++));
  2089.           needlogin = -1;
  2090.            }
  2091.            ret = pollserver(mesg, 0);
  2092.            if (ret < 0)
  2093.           return ret;
  2094.            if (!strncmp(mesg, "Password:", 9) || (!strncmp(mesg, "1 1", 3)))
  2095.           needlogin = 0;
  2096.            else if (!strncmp(mesg, "Sorry", 5)) {
  2097.           puts(mesg);
  2098.           if (!strncmp(mesg, "Sorry, the server is full", 24)) {
  2099.              mess->id = TOOMANY;
  2100.              return 1;
  2101.           }
  2102.           return 0;
  2103.            } else if (strlen(mesg) > 2 && strncmp(mesg, "Login", 5))
  2104.           puts(mesg);
  2105.         } while (needlogin);
  2106.         sendstr(getpassword(repeatpass++));
  2107.         do {
  2108.            ret = pollserver(mesg, 0);
  2109.            if (ret < 0)
  2110.           return ret;
  2111.            if (!strncmp(mesg, "Enter", 5))
  2112.           sendstr(getpassword(repeatpass++));
  2113.            if (!strncmp(mesg, "9 File", 6))
  2114.           needlogin = -1;
  2115.            if (!strncmp(mesg, "To get", 6))
  2116.           needlogin = 1;
  2117.            if (!strncmp(mesg, "#>", 2)) {
  2118.           sendstr("toggle client true\n");
  2119.           mess->id = ONSERVER;
  2120.           loggedon = 1;
  2121.           return 1;
  2122.            }
  2123.            if (strstr(mesg, "Invalid") || strstr(mesg, "your name")
  2124.          || strstr(mesg, "Too few") || strstr(mesg, "do not match")) {
  2125.           if (*mesg == '5')
  2126.              puts(mesg + 2);
  2127.           else
  2128.              puts(mesg);
  2129.           needlogin = 1;
  2130.            }
  2131.         } while (!needlogin);
  2132.         if (needlogin > 0)
  2133.            break;
  2134.      }            /* intentional fall through occurs here */
  2135.      loggedon = 1;
  2136.       default:
  2137.      mess->id = strtol(mesg, &textpart, 10);
  2138.      if (!loggedon && !mess->id) {
  2139.         mess->id = INTRO;
  2140.         strcpy(mess->text, mesg);
  2141.         return 1;
  2142.      }
  2143.      textpart++;
  2144.      if (mess->id == 2 && (strstr(textpart, "Game")
  2145.                    || strstr(textpart, "min")))
  2146.         mess->id = TIMEREP;
  2147.      if (appending == -1) {
  2148.         if (mess->id && !strncmp(textpart, "File", 4)) {
  2149.            appending = 0;
  2150.            if (mess->id == INFO &&
  2151.            !strncmp(mess->text, "~~~~~~~~~~~~~~~~~~~~~", 21))
  2152.           mess->id = QUITMESG;
  2153.            return 1;
  2154.         }
  2155.         if (strlen(mess->text)) {
  2156.            strcat(mess->text, "\n");
  2157.            mess->lines++;
  2158.         } {
  2159.            int len;
  2160.            char *pt;
  2161.            len = strlen(mesg);
  2162.            pt = mesg;
  2163.            while (len > 0) {
  2164.           strncat(mess->text, pt, 79);
  2165.           len -= 79;
  2166.           pt += 79;
  2167.           if (len > 0) {
  2168.              mess->lines++;
  2169.              strcat(mess->text, "\n");
  2170.           }
  2171.            }
  2172.         }
  2173.         return 0;
  2174.      }
  2175.      if (mess->id == PROMPT) {
  2176.             if (!verbosetog) 
  2177.            sendstr("toggle verbose false\n");
  2178.         if (*textpart == '5' && !loggedon)
  2179.            loggedon = 1;
  2180.         if (appending == MOVE && mess->movecount == 0 &&
  2181.         atoi(textpart) == 6 /* TEACHING */ ) {
  2182.            mess->id = MATCH;
  2183.            return 1;
  2184.         }
  2185.         if (appending) {
  2186.            mess->id = appending;
  2187.  
  2188.            appending = 0;
  2189.            return 1;
  2190.         }
  2191.         mess->prompttype = atoi(textpart);
  2192.      }
  2193.      if (!strcmp(textpart, "File")) {
  2194.         appending = -1;
  2195.         strcpy(mess->text, "");
  2196.         mess->lines = 1;
  2197.         return 0;
  2198.      }
  2199.      if (mess->id == BEEP) {
  2200.         mess->beep = (*textpart == 7);
  2201.      }
  2202.      if (mess->id == KIBITZ) {
  2203.         if (parsekibitz(textpart, mess))
  2204.            return 0;
  2205.      }
  2206.      if (mess->id == UNDO)
  2207.         if (ret = parseundo(textpart, &(mess->gamenum))) {
  2208.            if (ret < 0)
  2209.           return ret;
  2210.            return 0;
  2211.         }
  2212.      if (mess->id == SCORE) {
  2213.         sscanf(textpart, "%[^ ] (W:%*c):%f to %[^ ] (B:%*c):%f",
  2214.            mess->white, &(mess->wscore), mess->black, &(mess->bscore));
  2215.         return 1;
  2216.      }
  2217.      if (mess->id == TRANSLATE) {
  2218.         if (appending) {
  2219.            strcat(mess->text, "\n");
  2220.            strcat(mess->text, textpart);
  2221.            mess->lines++;
  2222.         } else {
  2223.            strcpy(mess->text, textpart);
  2224.            mess->lines = 1;
  2225.         }
  2226.         appending = TRANSLATE;
  2227.         return 0;
  2228.      }
  2229.      if (mess->id == MOVE) {
  2230.         appending = MOVE;
  2231.         parsemove(textpart, mess);
  2232.         return 0;
  2233.      }
  2234.      if (mess->id == WHO)
  2235.         return parsewho(mess, textpart);
  2236.      if (mess->id == GAMES) {
  2237.         appending = GAMES;
  2238.         parsegame(mess, textpart);
  2239.         return 0;
  2240.      }
  2241.      if (mess->id == STATUS)
  2242.         return parsestatus(mess, textpart);
  2243.      strcpy(mess->text, textpart);
  2244.      mess->lines = 1;
  2245.          if (mess->id == SHOUT) 
  2246.             return checkgame(textpart, mess);
  2247.      if (mess->id == ERROR &&
  2248.          !strcmp("Game not found.", textpart)) {
  2249.         mess->id = GAMES;
  2250.         mess->gamecount = 0;
  2251.         return 1;
  2252.      }
  2253.      if (mess->id == INFO)
  2254.         if (ret = parseinfo(textpart, mess))
  2255.            return ret;
  2256.      return 1;
  2257.    }
  2258.    return 0;
  2259.  
  2260. }
  2261.  
  2262. #ifdef STRTOL
  2263. long strtol(text, new, dum)
  2264. char *text;
  2265. char **new;
  2266. int dum;
  2267. {
  2268.    long retu;
  2269.    retu = atol(text);
  2270.    for (*new = text; *new && **new <= '9' && **new >= '0'; (*new)++);
  2271.    return retu;
  2272. }
  2273. #endif
  2274.  
  2275.  
  2276.  
  2277. #ifdef STRSTR
  2278. char *strstr(s1, s2)
  2279. char *s1, *s2;
  2280. {
  2281.    register char *temp;
  2282.    int len;
  2283.  
  2284.    temp = s1;
  2285.    len = strlen(s2);
  2286.    while (temp = strchr(temp, *s2)) {
  2287.       if (!strncmp(temp, s2, len))
  2288.      return temp;
  2289.       else
  2290.      temp++;
  2291.    }
  2292.    return NULL;
  2293. }
  2294. #endif
  2295.  
  2296.  
  2297.  
  2298. int parsestatus(mesg, s)
  2299. message *mesg;
  2300. char *s;
  2301. {
  2302.    int line, i;
  2303.    char wflag, bflag;
  2304.  
  2305.    if (1 == sscanf(s, " %d:", &line)) {
  2306.       mesg->boardsize = line + 1;
  2307.       for (i = 0, s += 4; *s; i++, s++)
  2308.      switch (*s) {
  2309.         case S_BLACK:
  2310.            mesg->board[line][i] = BLACK;
  2311.            break;
  2312.         case S_WHITE:
  2313.            mesg->board[line][i] = WHITE;
  2314.            break;
  2315.         case S_EMPTY:
  2316.         case S_HOSHI:
  2317.            mesg->board[line][i] = EMPTY;
  2318.            break;
  2319.         case S_WTERR:
  2320.            mesg->board[line][i] = WTERR;
  2321.            break;
  2322.         case S_BTERR:
  2323.            mesg->board[line][i] = BTERR;
  2324.            break;
  2325.         case S_DAME:
  2326.            mesg->board[line][i] = DAME;
  2327.            break;
  2328.      }
  2329.       if (i == line + 1)
  2330.      return 1;
  2331.    } else {
  2332.       if (!mesg->wnext) {
  2333.      sscanf(s, "%[^ ] %[^ ] %d %d %d %c %f %d",
  2334.         mesg->white, mesg->wrank, &(mesg->bcap), &(mesg->wtime),
  2335.         &(mesg->wbyo), &wflag, &(mesg->mykomi), &(mesg->hcap));
  2336.      if (wflag == 'F')
  2337.         mesg->wbyo = -1;
  2338.       } else {
  2339.      sscanf(s, "%[^ ] %[^ ] %d %d %d %c %f %d",
  2340.         mesg->black, mesg->brank, &(mesg->wcap), &(mesg->btime),
  2341.         &(mesg->bbyo), &bflag, &(mesg->mykomi), &(mesg->hcap));
  2342.      if (bflag == 'F')
  2343.         mesg->bbyo = -1;
  2344.       }
  2345.       mesg->wnext = !mesg->wnext;
  2346.    }
  2347.    return 0;
  2348. }
  2349.  
  2350. #define WHOLENGTH 34
  2351.  
  2352.  
  2353. int parsewho(mesg, str)
  2354. message *mesg;
  2355. char *str;
  2356. {
  2357.    if (!strncmp(str, " Info", 5)) {
  2358.       mesg->whocount = 0;
  2359.       strcpy(mesg->text, str);
  2360.       mesg->lines = 1;
  2361.       strcpy(mesg->whofirst, str);
  2362.    } else {
  2363.       strcat(mesg->text, "\n");
  2364.       strcat(mesg->text, str);
  2365.       mesg->lines++;
  2366.       if (strstr(str, "******")) {
  2367.      strcpy(mesg->wholast, str);
  2368.      return 1;
  2369.       } else {
  2370.      strncpy(mesg->who[mesg->whocount++], str, WHOLENGTH);
  2371.      if (strlen(str) > 40)
  2372.         strncpy(mesg->who[mesg->whocount++], str + 37, WHOLENGTH);
  2373.       }
  2374.    }
  2375.    return 0;
  2376. }
  2377.  
  2378.  
  2379. parsegame(mesg, str)
  2380. message *mesg;
  2381. char *str;
  2382. {
  2383.    int fieldcount;
  2384.    char *br, *wr, blackrank[10], whiterank[10];
  2385.    if (str[1] == '#') {
  2386.       mesg->gamecount = 0;
  2387.       strcpy(mesg->text, str);
  2388.       strcpy(mesg->gamefirst, str);
  2389.       mesg->lines = 1;
  2390.    } else {
  2391.       strcpy(mesg->gamelist[mesg->gamecount].gametext, str);
  2392.       strcat(mesg->gamelist[mesg->gamecount].gametext, "\n");
  2393.       strcat(mesg->text, "\n");
  2394.       strcat(mesg->text, str);
  2395.       mesg->lines++;
  2396.  
  2397.       /* hacked for systems that don't like %[^]] */
  2398.       for (br = str; *br; br++)
  2399.      if (*br == ']')
  2400.         *br = '!';
  2401.       fieldcount = sscanf(str, "[%3d!%12s [%[^!]! vs.%12s [%[^!]! (%3d %d %d %f %d) ( %d)\n",
  2402.               &(mesg->gamelist[mesg->gamecount].gnum),
  2403.               mesg->gamelist[mesg->gamecount].white,
  2404.               whiterank,
  2405.               mesg->gamelist[mesg->gamecount].black,
  2406.               blackrank,
  2407.               &(mesg->gamelist[mesg->gamecount].mnum),
  2408.               &(mesg->gamelist[mesg->gamecount].bsize),
  2409.               &(mesg->gamelist[mesg->gamecount].hcap),
  2410.               &(mesg->gamelist[mesg->gamecount].komi),
  2411.               &(mesg->gamelist[mesg->gamecount].byo),
  2412.               &(mesg->gamelist[mesg->gamecount].obcount));
  2413.       br = blackrank;
  2414.       wr = whiterank;
  2415.       if (*br == ' ')
  2416.      br++;
  2417.       if (*wr == ' ')
  2418.      wr++;
  2419.       strcpy(mesg->gamelist[mesg->gamecount].wrank, wr);
  2420.       strcpy(mesg->gamelist[mesg->gamecount].brank, br);
  2421.       if (fieldcount == 11)
  2422.      (mesg->gamecount)++;
  2423.    }
  2424. }
  2425.  
  2426.  
  2427. int parseinfo(s, mess)
  2428. char *s;
  2429. message *mess;
  2430. {
  2431.    int ret;
  2432.    extern int boardsize;
  2433.    int row;
  2434.    char col;
  2435.    char text[100];
  2436.  
  2437.    if (checkgame(s, mess)) { mess->id = ENDGAMEINFO;return 0;}
  2438.    if (!strcmp(s, "Set verbose to be False.")) {
  2439.       mess->id = 0;
  2440.       verbosetog = 1;
  2441.       return 0;
  2442.    }
  2443.    if (!strcmp(s, "Set verbose to be True.")) {
  2444.       mess->id = 0;
  2445.       verbosetog = 0;
  2446.       return 0;
  2447.    }
  2448.    if (1 == sscanf(s, "Set the komi to %f.", &(mess->mykomi))) {
  2449.       mess->id = CHKOMI;
  2450.       return 0;
  2451.    }
  2452.    if (2 == sscanf(s, "Match [%dx%d]", &ret, &ret))
  2453.       return 0;
  2454.    if (1 == sscanf(s, "Match [%d]", &(mess->gamenum))) {
  2455.       mess->id = MATCH;
  2456.       return 0;
  2457.    }
  2458.    if (1 == sscanf(s, "Creating match [%d]", &(mess->gamenum))) {
  2459.       mess->id = MATCH;
  2460.       return 0;
  2461.    }
  2462.    if (2 == sscanf(s, "Removing @ %c%d", &col, &row)) {
  2463.  
  2464.       if (col > 'I')
  2465.      col--;
  2466.       mess->x = col - 'A';
  2467.       mess->y = boardsize - row;
  2468.       mess->id = REMOVE;
  2469.       return 0;
  2470.    }
  2471.    if (!strcmp(s, "Type 'done' when finished")) {
  2472.       mess->id = STARTSCORE;
  2473.       return 0;
  2474.    }
  2475.    if (!strncmp(s, "Board is restored", 17)) {
  2476.       mess->id = SCOREUNDO;
  2477.       return 0;
  2478.    }
  2479.    if (strstr(s, "has restored your old game.")) {
  2480.       char eat = 3, match = 0;
  2481.       mess->id = LOAD;
  2482.       for (; eat; eat--) {
  2483.      ret = pollserver(text, 0);
  2484.      if (ret < 0)
  2485.         return ret;
  2486.      if (!match)
  2487.         match = sscanf(text, "%*d Game %d: %*[^(](%d %d %d) vs %*[^(](%d %d %d)",
  2488.                &(mess->gamenum), &(mess->bcap), &(mess->btime),
  2489.            &(mess->bbyo), &(mess->wcap), &(mess->wtime), &(mess->wbyo)
  2490.            );
  2491.       }
  2492.       return 0;
  2493.    }
  2494.    return 0;
  2495. }
  2496.  
  2497.  
  2498. int parseundo(s, gamenum)
  2499. char *s;
  2500. int *gamenum;
  2501. {
  2502.    char mes[2000];
  2503.    int count;
  2504.    int bogus2, ret;
  2505.    char bogus1;
  2506.    count = sscanf(s, "%*[^ ] undid the last move (%c%d).", &bogus1, &bogus2);
  2507.    if (count == 2) {
  2508.       ret = pollserver(mes, 0);
  2509.       if (ret < 0)
  2510.      return ret;
  2511.       ret = pollserver(mes, 0);
  2512.       if (ret < 0)
  2513.      return ret;
  2514.       sscanf(mes, "%*d Game %d", gamenum);
  2515.       ret = pollserver(mes, 0);
  2516.       if (ret < 0)
  2517.      return ret;
  2518.       return 0;
  2519.    }
  2520.    if (1 == sscanf(s, "%*[^ ] undid the last move (Handicap %d).", &bogus2))
  2521.       return 0;
  2522.    count = sscanf(s, "Undo in game %d", gamenum);
  2523.    if (count != 1)
  2524.       return 1;            /* extra line */
  2525.    return 0;
  2526. }
  2527.  
  2528.  
  2529. int checkgame(s, mess)
  2530. char *s;
  2531. message *mess;
  2532. { 
  2533.    if (!strncmp(s,"{Game ",6) && (strstr(s,"resigns.") ||  
  2534.      strstr(s,"forfeits on time.") || strstr(s, "adjourned."))){
  2535.  
  2536.      mess->id = ENDGAME;
  2537.      sscanf(s, "{Game %d", &(mess->gamenum));
  2538.      return 1;
  2539.    } 
  2540.    return 0;
  2541. }
  2542.      
  2543.  
  2544. int parsekibitz(s, mess)
  2545. char *s;
  2546. message *mess;
  2547. {
  2548.    if (1 == sscanf(s, "Kibitz %[^:]", mess->kibitzer))
  2549.       return 1;
  2550.    while (*s == ' ')
  2551.       s++;
  2552.    strcpy(mess->kibitz, s);
  2553.    return 0;
  2554.  
  2555. }
  2556.  
  2557.  
  2558. parsemove(s, mess)
  2559. char *s;
  2560. message *mess;
  2561. {
  2562.    int mc, y, mv;
  2563.    char c, col;
  2564.    extern int boardsize;
  2565.  
  2566.    if (!strncmp(s, "Game ", 5)) {
  2567.       sscanf(s, "Game %d: %*[^(](%d %d %d) vs %*[^(](%d %d %d)",
  2568.          &(mess->gamenum), &(mess->wcap), &(mess->wtime),
  2569.          &(mess->wbyo), &(mess->bcap),
  2570.          &(mess->btime), &(mess->bbyo));
  2571.       mess->movecount = 0;
  2572.       return;
  2573.    }
  2574.    mc = sscanf(s, "%3d(%c): %c%d", &mv, &c, &col, &y);
  2575.    if (mc == 3) {
  2576.       if (3 == sscanf(s, "%3d(%c): Handicap %d", &mv, &c, &mc)) {
  2577.      mess->moves[mess->movecount].x = mess->moves[mess->movecount].y = mc + 100;
  2578.      mess->moves[mess->movecount].color = c == 'W' ? 2 : 1;
  2579.      mess->moves[mess->movecount].movenum = mv + 1;
  2580.      mess->movecount++;
  2581.      return;
  2582.       }
  2583.       if (2 == sscanf(s, "%3d(%c): Pass", &mv, &c)) {
  2584.      mess->moves[mess->movecount].x = mess->moves[mess->movecount].y = 99;
  2585.      mess->moves[mess->movecount].color = c == 'W' ? 2 : 1;
  2586.      mess->moves[mess->movecount].movenum = mv + 1;
  2587.      mess->movecount++;
  2588.      return;
  2589.       }
  2590.    }
  2591.    if (col > 'I')
  2592.       col--;
  2593.    mess->moves[mess->movecount].x = col - 'A';
  2594.    mess->moves[mess->movecount].y = boardsize - y;
  2595.    mess->moves[mess->movecount].color = c == 'W' ? 2 : 1;
  2596.    mess->moves[mess->movecount].movenum = mv + 1;
  2597.    mess->movecount++;
  2598. }
  2599.  
  2600.  
  2601. int doneline(inbuf, inptr)
  2602. char *inbuf;
  2603. int inptr;
  2604. {
  2605.    return !loggedon &&
  2606.       (inptr > 0 && inbuf[inptr - 1] == ' ') &&
  2607.       ((inptr > 1 && inbuf[inptr - 2] == ':') ||
  2608.        (inptr > 2 && inbuf[inptr - 2] == '>' && inbuf[inptr - 3] == '#'));
  2609. }
  2610. SHAR_EOF
  2611. fi
  2612. if test -f 'ascii.c'
  2613. then
  2614.     echo shar: "will not over-write existing file 'ascii.c'"
  2615. else
  2616. cat << \SHAR_EOF > 'ascii.c'
  2617.  
  2618. #include <curses.h>
  2619.  
  2620. #define piece char
  2621.  
  2622. #define TOP 2
  2623. #define LEFT 3
  2624. #define RIGHT 79
  2625. #define min(a,b) (((a)<(b))?(a):(b))
  2626. #define TITLEX 6
  2627. #define HIGHLIGHT 23
  2628.  
  2629. #define   CHAR_NOTHING 0
  2630. #define   CHAR_BLACK 1
  2631. #define   CHAR_WHITE 2
  2632. #define   CHAR_DAME 3
  2633. #define   CHAR_BLACKTERR 4
  2634. #define   CHAR_WHITETERR 5
  2635. #define   CHAR_HANDICAP 6
  2636. #define   CHAR_VERT 7
  2637. #define   ASC_NUMCHARS 8
  2638.  
  2639.  
  2640. WINDOW *boardwin, *serverwin, *iowin;
  2641. char xAxisChars[] = "ABCDEFGHJKLMNOPQRST";
  2642. int inverseFlag = 1;
  2643. int inverseBorder = 0;
  2644. int lastwin = 1;
  2645. int boardsize = -1;
  2646. char chars[] = ".#O?+-+ ";
  2647. int servecols = -1;
  2648. static int init = 0;
  2649. int endw = -1, endb = -1;
  2650. int reinit = 0;
  2651. int doedgemarkers = 0;
  2652. int dopiecemarkers = 1;
  2653.  
  2654.  
  2655. setedgemark(mark)
  2656. int mark;
  2657. {
  2658.    doedgemarkers = mark;
  2659. }
  2660.  
  2661. setpiecemark(mark)
  2662. int mark;
  2663. {
  2664.    dopiecemarkers = mark;
  2665. }
  2666.  
  2667. setinverse(inv)
  2668. int inv;
  2669. {
  2670.    inverseFlag = inv;
  2671. }
  2672.  
  2673. setinverseborder(inv)
  2674. int inv;
  2675. {
  2676.    inverseBorder = inv;
  2677. }
  2678.  
  2679. setborder(ch)
  2680. char ch;
  2681. {
  2682.    chars[CHAR_VERT] = ch;
  2683. }
  2684.  
  2685. setchars(s)
  2686. char *s;
  2687. {
  2688.    int i;
  2689.    for (i = 0; i <= min(CHAR_VERT, strlen(s) - 1); i++)
  2690.       chars[i] = s[i];
  2691. }
  2692.  
  2693.  
  2694. serverrefresh()
  2695. {
  2696.    if (lastwin)
  2697.       wrefresh(iowin);
  2698.    else
  2699.       wrefresh(serverwin);
  2700. }
  2701.  
  2702. boardrefresh()
  2703. {
  2704.    wrefresh(boardwin);
  2705. }
  2706.  
  2707. void initAscii()
  2708. {
  2709.    if (!init) {
  2710.       init = 1;
  2711.       initscr();
  2712.       noecho();
  2713.       crmode();
  2714.    }
  2715. }
  2716.  
  2717. suspend()
  2718. {
  2719.    move(23, 0);
  2720.    refresh();
  2721.    echo();
  2722.    nocrmode();
  2723. }
  2724.  
  2725.  
  2726.  
  2727. redraw()
  2728. {
  2729.    clearok(stdscr, TRUE);
  2730.    refresh();
  2731.    clearok(stdscr, FALSE);
  2732. }
  2733.  
  2734.  
  2735. unsuspend()
  2736. {
  2737.    noecho();
  2738.    crmode();
  2739.    redraw();
  2740. }
  2741.  
  2742.  
  2743. displaygamenumber(n)
  2744. int n;
  2745. {
  2746.    move(0, 0);
  2747.    if (n >= 0)
  2748.       printw("%3d", n);
  2749.    else if (n == -1)
  2750.       printw("-- ");
  2751.    else
  2752.       printw("sta");
  2753.    refresh();
  2754. }
  2755.  
  2756. boardtitle(bs, ws)
  2757. char *bs, *ws;
  2758. {
  2759.    int i;
  2760.    move(0, TITLEX);
  2761.    for (i = 0; i < 35; i++)
  2762.       addch(' ');
  2763.    move(1, TITLEX);
  2764.    for (i = 0; i < 35; i++)
  2765.       addch(' ');
  2766.    if (strlen(bs)) {
  2767.       move(0, TITLEX);
  2768.       printw("Black: %s", bs);
  2769.       endb = TITLEX + 8 + strlen(bs);
  2770.       move(1, TITLEX);
  2771.       printw("White: %s", ws);
  2772.       endw = TITLEX + 8 + strlen(ws);
  2773.    }
  2774.    refresh();
  2775. }
  2776.  
  2777. static void sbinverse()
  2778. {
  2779.    if (inverseBorder)
  2780.       wstandout(boardwin);
  2781. }
  2782.  
  2783. static void set_inverse()
  2784. {
  2785.    if (inverseFlag)
  2786.       wstandout(boardwin);
  2787. }
  2788.  
  2789. static void unset_inverse()
  2790. {
  2791.    wstandend(boardwin);
  2792. }
  2793.  
  2794.  
  2795. setcursor(x, y)
  2796. int x, y;
  2797. {
  2798.    wmove(boardwin, TOP + y, LEFT + 2 * x);
  2799.    wrefresh(boardwin);
  2800. }
  2801.  
  2802.  
  2803. void drawPiece(i, j, c)
  2804. int i, j;
  2805. char c;
  2806. {
  2807.    wmove(boardwin, TOP + j, LEFT + 2 * i);
  2808.    set_inverse();
  2809.    waddch(boardwin, c);
  2810.    unset_inverse();
  2811. }
  2812.  
  2813.  
  2814. void deleteBoardAscii()
  2815. {
  2816.    delwin(boardwin);
  2817.    delwin(serverwin);
  2818.    delwin(iowin);
  2819. }
  2820.  
  2821.  
  2822. void endAscii()
  2823. {
  2824.    init = 0;
  2825.    deleteBoardAscii();
  2826.    boardsize = -1;
  2827.    clear();
  2828.    refresh();
  2829.    echo();
  2830.    nocrmode();
  2831.    endwin();
  2832. }
  2833.  
  2834.  
  2835. char boardPiece(x, y, boardsize)
  2836. int x, y, boardsize;
  2837. {
  2838.    return
  2839.  
  2840.       (((boardsize == 19 && x == 9) || (boardsize >= 10 &&
  2841.                     (x == 3 || x == boardsize - 4))
  2842.     || (boardsize > 6 && boardsize < 10 &&
  2843.         (x == 2 || x == boardsize - 3))) &&
  2844.        ((boardsize == 19 && y == 9) ||
  2845.     (boardsize >= 10 && (y == 3 || y == boardsize - 4))
  2846.     || (boardsize > 6 && boardsize < 10 &&
  2847.         (y == 2 || y == boardsize - 3))))
  2848.       ? chars[(int) CHAR_HANDICAP] : chars[(int) CHAR_NOTHING];
  2849. }
  2850.  
  2851.  
  2852.  
  2853. drawOneStone(i, j, t)
  2854. int i, j;
  2855. piece t;
  2856. {
  2857.    if (t == 0)
  2858.       drawPiece(i, j, boardPiece(i, j, boardsize));
  2859.    else
  2860.       drawPiece(i, j, chars[t]);
  2861.    wrefresh(boardwin);
  2862. }
  2863.  
  2864. drawStone(i, j, t)
  2865. int i, j;
  2866. piece t;
  2867. {
  2868.    if (t == 0)
  2869.       drawPiece(i, j, boardPiece(i, j, boardsize));
  2870.    else
  2871.       drawPiece(i, j, chars[t]);
  2872. }
  2873.  
  2874.  
  2875. unmarkascii(i, j)
  2876. int i, j;
  2877. {
  2878.    if (!init)
  2879.       return;
  2880.    if (i >= 0 && i <= 19) {
  2881.       set_inverse();
  2882.       if (dopiecemarkers) {
  2883.      wmove(boardwin, TOP + j, LEFT + 2 * i - 1);
  2884.      waddch(boardwin, ' ');
  2885.      wmove(boardwin, TOP + j, LEFT + 2 * i + 1);
  2886.      waddch(boardwin, ' ');
  2887.       }
  2888.       if (doedgemarkers) {
  2889.      wmove(boardwin, TOP + j, LEFT - 1);
  2890.      waddch(boardwin, chars[CHAR_VERT]);
  2891.      wmove(boardwin, TOP + j, LEFT + boardsize * 2 - 1);
  2892.      waddch(boardwin, chars[CHAR_VERT]);
  2893.      unset_inverse();
  2894.      sbinverse();
  2895.      wmove(boardwin, TOP - 1, LEFT + i * 2);
  2896.      waddch(boardwin, xAxisChars[i]);
  2897.      wmove(boardwin, TOP + boardsize, LEFT + i * 2);
  2898.      waddch(boardwin, xAxisChars[i]);
  2899.       }
  2900.       unset_inverse();
  2901.    }
  2902. }
  2903.  
  2904. unhighlight(i, j)
  2905. int i, j;
  2906. {
  2907.    int k;
  2908.    if (!init)
  2909.       return;
  2910.    move(HIGHLIGHT, 0);
  2911.    for (k = 1; k < 80 - servecols; k++)
  2912.       addch(' ');
  2913.    move(0, TITLEX - 2);
  2914.    printw("  ");
  2915.    move(1, TITLEX - 2);
  2916.    printw("  ");
  2917.    unmarkascii(i, j);
  2918. }
  2919.  
  2920. static char *who[] =
  2921. {"Black", "White"};
  2922.  
  2923. showhcap(hcap)
  2924. int hcap;
  2925. {
  2926.    if (!init)
  2927.       return;
  2928.    move(0, LEFT + 19 * 2 + 1);
  2929.    if (hcap)
  2930.       printw("%d", hcap);
  2931.    else
  2932.       addch(' ');
  2933.    refresh();
  2934. }
  2935.  
  2936. showkomi(komi)
  2937. float komi;
  2938. {
  2939.    if (!init)
  2940.       return;
  2941.    move(1, LEFT + 19 * 2 - 1);
  2942.    printw("%1.1f", komi);
  2943.    refresh();
  2944. }
  2945.  
  2946. highlight(i, j, num, t, btime, bbyo, wtime, wbyo)
  2947. int i, j;
  2948. piece t;
  2949. int btime, bbyo, wtime, wbyo;
  2950. {
  2951.    int k;
  2952.    if (btime != -1) {
  2953.       move(0, endb);
  2954.       if (btime < 0)
  2955.      btime = 0;
  2956.       if (wtime < 0)
  2957.      wtime = 0;
  2958.       printw("%d:%02d", btime / 60, btime % 60);
  2959.       if (bbyo != -1)
  2960.      printw(", %d", bbyo);
  2961.       addstr("   ");
  2962.       move(1, endw);
  2963.       printw("%d:%02d", wtime / 60, wtime % 60);
  2964.       if (wbyo != -1)
  2965.      printw(", %d", wbyo);
  2966.       addstr("   ");
  2967.    }
  2968.    if (t >= 0) {
  2969.       move(t == 1 ? 1 : 0, TITLEX - 2);
  2970.       printw("->");
  2971.    }
  2972.    move(HIGHLIGHT, 0);
  2973.    for (k = 1; k < 80 - servecols; k++)
  2974.       addch(' ');
  2975.    if (i == 99) {
  2976.       move(HIGHLIGHT, 0);
  2977.       printw("%s #%d Pass", who[t - 1], num);
  2978.    } else if (i < 100 && num) {
  2979.       move(HIGHLIGHT, 0);
  2980.       printw("%s #%d at %c%d", who[t - 1], num, i + 'A' +
  2981.          (i + 'A' >= 'I' ? 1 : 0), boardsize - j);
  2982.       set_inverse();
  2983.       if (dopiecemarkers) {
  2984.      wmove(boardwin, TOP + j, LEFT + 2 * i - 1);
  2985.      waddch(boardwin, '>');
  2986.      wmove(boardwin, TOP + j, LEFT + 2 * i + 1);
  2987.      waddch(boardwin, '<');
  2988.       }
  2989.       if (doedgemarkers) {
  2990.      wmove(boardwin, TOP + j, LEFT - 1);
  2991.      waddch(boardwin, '>');
  2992.      wmove(boardwin, TOP + j, LEFT + boardsize * 2 - 1);
  2993.      waddch(boardwin, '<');
  2994.      unset_inverse();
  2995.      sbinverse();
  2996.      wmove(boardwin, TOP - 1, LEFT + i * 2);
  2997.      waddch(boardwin, '!');
  2998.      wmove(boardwin, TOP + boardsize, LEFT + i * 2);
  2999.      waddch(boardwin, '!');
  3000.       }
  3001.       unset_inverse();
  3002.    }
  3003. }
  3004.  
  3005.  
  3006.  
  3007. drawpris(pris)
  3008. int *pris;
  3009. {
  3010.    move(23, 22);
  3011.    printw("Captured %c: %d  %c: %d  ", chars[CHAR_BLACK], *pris,
  3012.       chars[CHAR_WHITE], pris[1]);
  3013.    refresh();
  3014. }
  3015.  
  3016.  
  3017.  
  3018. void initBoardAscii(size)
  3019. int size;
  3020. {
  3021.    int i, j;
  3022.    if (!reinit) {
  3023.       if (size == boardsize) {
  3024.      for (i = boardsize; i--;)
  3025.         for (j = boardsize; j--;)
  3026.            drawStone(i, j, 0);
  3027.      return;
  3028.       }
  3029.       if (boardsize != -1)
  3030.      deleteBoardAscii();
  3031.       boardsize = size;
  3032.       clear();
  3033.       boardwin = subwin(stdscr, boardsize + 4, boardsize * 2 - 1 + 6 + 2, 1, 0);
  3034.       servecols = COLS - 19 * 2 - 6 - 2;
  3035.       serverwin = subwin(stdscr, 22, servecols, 0, 19 * 2 - 1 + 6 + 2);
  3036.  
  3037.       iowin = subwin(stdscr, 2, servecols, 22, 19 * 2 - 1 + 6 + 2);
  3038.    }
  3039.    if (inverseFlag || reinit) {
  3040.       set_inverse();
  3041.       for (i = LEFT + 1; i < LEFT + boardsize * 2 - 2; i += 2)
  3042.      for (j = TOP; j < TOP + boardsize; j++)
  3043.         mvwaddch(boardwin, j, i, ' ');
  3044.       unset_inverse();
  3045.    }
  3046.    for (i = boardsize; i--;) {
  3047.       /* left */
  3048.       wmove(boardwin, TOP + i, LEFT - 3);
  3049.       sbinverse();
  3050.       wprintw(boardwin, "%2d", boardsize - i);
  3051.       unset_inverse();
  3052.       set_inverse();
  3053.       waddch(boardwin, chars[(int) CHAR_VERT]);
  3054.  
  3055.       /* right */
  3056.       wmove(boardwin, TOP + i, LEFT + boardsize * 2 - 1);
  3057.       waddch(boardwin, chars[(int) CHAR_VERT]);
  3058.       unset_inverse();
  3059.       sbinverse();
  3060.       wprintw(boardwin, "%2d", boardsize - i);
  3061.       unset_inverse();
  3062.       waddch(boardwin, chars[(int) CHAR_VERT]);
  3063.  
  3064.       /* top */
  3065.       wmove(boardwin, TOP - 1, LEFT + i * 2);
  3066.       sbinverse();
  3067.       waddch(boardwin, xAxisChars[i]);
  3068.       waddch(boardwin, ' ');
  3069.       unset_inverse();
  3070.       wmove(boardwin, TOP - 1, LEFT + i * 2 - 1);
  3071.       set_inverse();
  3072.  
  3073.       /* bottom */
  3074.       wmove(boardwin, TOP + boardsize, LEFT + i * 2 - 1);
  3075.       unset_inverse();
  3076.       wmove(boardwin, TOP + boardsize, LEFT + i * 2);
  3077.       sbinverse();
  3078.       waddch(boardwin, xAxisChars[i]);
  3079.       waddch(boardwin, ' ');
  3080.       unset_inverse();
  3081.       for (j = boardsize; j--;)
  3082.      drawStone(i, j, 0);
  3083.    }
  3084.  
  3085.    sbinverse();
  3086.    wmove(boardwin, TOP - 1, LEFT - 3);
  3087.    waddstr(boardwin, "   ");
  3088.    wmove(boardwin, TOP + boardsize, LEFT - 3);
  3089.    waddstr(boardwin, "   ");
  3090.    wmove(boardwin, TOP - 1, LEFT + 2 * boardsize);
  3091.    waddstr(boardwin, "  ");
  3092.    wmove(boardwin, TOP + boardsize, LEFT + 2 * boardsize);
  3093.    waddstr(boardwin, "  ");
  3094.    unset_inverse();
  3095.  
  3096.    wmove(boardwin, size / 2, size / 2);
  3097. }
  3098.  
  3099. reinitboardascii()
  3100. {
  3101.    reinit = 1;
  3102.    initBoardAscii(boardsize);
  3103.    reinit = 0;
  3104. }
  3105.  
  3106.  
  3107. clearserver()
  3108. {
  3109.    wclear(serverwin);
  3110.    wrefresh(serverwin);
  3111. }
  3112.  
  3113.  
  3114. addcharline(pos, ch)
  3115. int pos;
  3116. char ch;
  3117. {
  3118.    wmove(iowin, 1, pos);
  3119.    waddch(iowin, ch);
  3120.    wrefresh(iowin);
  3121.    lastwin = 1;
  3122. }
  3123.  
  3124.  
  3125. deletechar(pos)
  3126. int pos;
  3127. {
  3128.    wmove(iowin, 1, pos);
  3129.    waddch(iowin, ' ');
  3130.    wmove(iowin, 1, pos);
  3131.    wrefresh(iowin);
  3132.    lastwin = 1;
  3133. }
  3134.  
  3135.  
  3136. int linesize()
  3137. {
  3138.    return servecols - 1;
  3139. }
  3140.  
  3141. clrline()
  3142. {
  3143.    wmove(iowin, 1, 0);
  3144.    wclrtoeol(iowin);
  3145.    wrefresh(iowin);
  3146. }
  3147.  
  3148.  
  3149. addchar(ch)
  3150. char ch;
  3151. {
  3152.    int x, y, maxx, maxy;
  3153.    if (ch == '\r')
  3154.       return;
  3155.    waddch(serverwin, ch);
  3156.    maxy = serverwin->_maxy - 1;    /* 20 */
  3157.    maxx = serverwin->_maxx - 1;    /* servecols - 1; */
  3158.    getyx(serverwin, y, x);
  3159.    if ((x == maxx - 1 && y == maxy) || (ch == '\n' && y == maxy) ||
  3160.        y > maxy) {
  3161.       wmove(serverwin, 0, 0);
  3162.       wclrtoeol(serverwin);
  3163.    } else if (x == 0 && y <= maxy) {
  3164.       wclrtoeol(serverwin);
  3165.       wmove(serverwin, y + 1, 0);
  3166.       wclrtoeol(serverwin);
  3167.       wmove(serverwin, y, x);
  3168.    }
  3169.    wrefresh(serverwin);
  3170.    lastwin = 0;
  3171. }
  3172.  
  3173. showprefix(s)
  3174. char *s;
  3175. {
  3176.    wmove(iowin, 0, 0);
  3177.    wclrtoeol(iowin);
  3178.    if (strlen(s))
  3179.       wprintw(iowin, "Prefix: '%s'", s);
  3180.    wrefresh(iowin);
  3181. }
  3182.  
  3183.  
  3184. /* addstring(s) char *s; { char *p; for (p = s; *p; p++) addchar(*p); } */
  3185.  
  3186.  
  3187. void addstring(s)
  3188. char *s;
  3189. {
  3190.    char *wordstart;
  3191.    char *curptr;
  3192.    int haveblank, linelen;
  3193.  
  3194.    curptr = wordstart = s;
  3195.    linelen = 0;
  3196.    while (*curptr) {
  3197.       while (*curptr && *curptr != ' ' && *curptr != '\n') {
  3198.      linelen++;
  3199.      curptr++;
  3200.       }
  3201.       if (*curptr) {
  3202.      haveblank = 1;
  3203.      linelen++;
  3204.      curptr++;
  3205.       } else
  3206.      haveblank = 0;
  3207.  
  3208.       if (linelen <= linesize()) {
  3209.      while (wordstart != curptr)
  3210.         addchar(*wordstart++);
  3211.      if (haveblank && *(curptr - 1) == '\n')
  3212.         linelen = 0;
  3213.       } else if (haveblank && (linelen - 1 <= linesize())) {
  3214.      while (wordstart != curptr - 1)
  3215.         addchar(*wordstart++);
  3216.      addchar('\n');
  3217.      wordstart++;
  3218.      linelen = 0;
  3219.       } else {
  3220.      if ((curptr - wordstart) > linesize()) {
  3221.         while ((curptr - wordstart) > linesize()) {
  3222.            int i;
  3223.            for (i = linesize(); i; i--)
  3224.           addchar(*wordstart++);
  3225.            addchar('\n');
  3226.         }
  3227.      } else
  3228.         addchar('\n');
  3229.  
  3230.      linelen = 0;
  3231.      while (wordstart != curptr) {
  3232.         addchar(*wordstart++);
  3233.         linelen++;
  3234.      }
  3235.  
  3236.       }
  3237.    }
  3238. }
  3239.  
  3240.  
  3241.  
  3242. bigmess(lines, intext)
  3243. int lines;
  3244. char *intext;
  3245. {
  3246.    WINDOW *savescr;
  3247.    char ch;
  3248.    int i, count;
  3249.    int rest;
  3250.    char *mynl, *localcopy, *text;
  3251.  
  3252.    text = localcopy = (char *) malloc(strlen(intext) + 1);
  3253.    strcpy(text, intext);
  3254.    mynl = "";
  3255.    if (lines > 22) {
  3256.       rest = lines;
  3257.       lines = 22;
  3258.    } else
  3259.       rest = 0;
  3260.    savescr = newwin(24, 80, 0, 0);
  3261.    overwrite(stdscr, savescr);
  3262.    do {
  3263.       if (rest > 0) {
  3264.      for (mynl = text, count = 22; count && *mynl; mynl++)
  3265.         if (*mynl == '\n')
  3266.            count--;
  3267.      *(mynl - 1) = 0;
  3268.      rest -= 22;
  3269.       }
  3270.       for (i = (24 - lines) / 2 - 1; i < (24 - lines) / 2 + lines + 1; i++) {
  3271.      move(i, 0);
  3272.      clrtoeol();
  3273.       }
  3274.       move((24 - lines) / 2, 0);
  3275.       addstr(text);
  3276.       refresh();
  3277.       while (read(0, &ch, 1) != 1);
  3278.       text = mynl;
  3279.    } while (rest > 0);
  3280.    overwrite(savescr, stdscr);
  3281.    refresh();
  3282.    delwin(savescr);
  3283.    free(localcopy);
  3284. }
  3285. SHAR_EOF
  3286. fi
  3287. if test -f 'board.c'
  3288. then
  3289.     echo shar: "will not over-write existing file 'board.c'"
  3290. else
  3291. cat << \SHAR_EOF > 'board.c'
  3292. #include "igc.h"
  3293.  
  3294. typedef char boardtype[19][19];
  3295. int prisoners[2];
  3296. int movenum, maxmove;
  3297.  
  3298. typedef struct {
  3299.    int x, y;
  3300.    char col;
  3301. }  movelist[500];
  3302.  
  3303. movelist moves;
  3304.  
  3305. boardtype board;
  3306.  
  3307. #define boolean char
  3308. #define false 0
  3309. #define true 1
  3310.  
  3311. static int boardsize = -1;
  3312.  
  3313. int lasti = -1, lastj = -1;
  3314.  
  3315.  
  3316. clearboard(b, pris)
  3317. boardtype b;
  3318. int *pris;
  3319. {
  3320.    int i, j;
  3321.    pris[0] = pris[1] = 0;
  3322.    for (i = 0; i < boardsize; i++)
  3323.       for (j = 0; j < boardsize; j++)
  3324.      b[i][j] = EMPTY;
  3325. }
  3326.  
  3327.  
  3328. initboard(size)
  3329. int size;
  3330. {
  3331.    clearboard(board, prisoners);
  3332.    unhighlight(lasti, lastj);
  3333.    showhcap(0);
  3334.    initAscii();
  3335.    initBoardAscii(size);
  3336.    boardsize = size;
  3337.    maxmove = movenum = 0;
  3338. }
  3339.  
  3340.  
  3341. reinitboard(size)
  3342. int size;
  3343. {
  3344.    unhighlight(lasti, lastj);
  3345.    showhcap(0);
  3346.    clearboard(board, prisoners);
  3347.    initAscii();
  3348.    reinitboardascii();
  3349.    boardsize = size;
  3350. }
  3351.  
  3352. boolean inRange(i, j)
  3353. {
  3354.    return i >= 0 && i < boardsize && j >= 0 && j < boardsize;
  3355. }
  3356.  
  3357. boolean alive0(b, m, i, j, t)
  3358. boardtype b;
  3359. boardtype m;
  3360. int i, j;
  3361. piece t;
  3362. {
  3363.    piece pt;
  3364.  
  3365.    pt = b[i][j];
  3366.    if ((pt != EMPTY && pt != t) || m[i][j] != EMPTY)
  3367.       return 0;
  3368.    m[i][j] = (pt == t) ? (piece) 1 : (piece) 2;
  3369.    if (pt == EMPTY)
  3370.       return 1;
  3371.    return
  3372.       (j < boardsize - 1 && alive0(b, m, i, j + 1, t)) ||
  3373.       (i < boardsize - 1 && alive0(b, m, i + 1, j, t)) ||
  3374.       (i && alive0(b, m, i - 1, j, t)) ||
  3375.       (j && alive0(b, m, i, j - 1, t));
  3376. }
  3377.  
  3378. boolean alive(b, i, j)        /* Does group at i,j have liberties? */
  3379. boardtype b;
  3380. int i, j;
  3381. {
  3382.    boardtype m;
  3383.    int p[2];
  3384.  
  3385.    clearboard(m, p);
  3386.    return alive0(b, m, i, j, b[i][j]);
  3387. }
  3388.  
  3389. int removed;
  3390. int dontdraw = 0;
  3391.  
  3392. void removeStones0(b, pris, i, j, t)
  3393. boardtype b;
  3394. int *pris;
  3395. int i, j;
  3396. piece t;
  3397. {
  3398.    if (b[i][j] != t)
  3399.       return;
  3400.    b[i][j] = EMPTY;
  3401.    if (!dontdraw)
  3402.       drawStone(i, j, 0);
  3403.    removed = 1;
  3404.    pris[t - 1]++;
  3405.    if (j < boardsize - 1)
  3406.       removeStones0(b, pris, i, j + 1, t);
  3407.    if (i < boardsize - 1)
  3408.       removeStones0(b, pris, i + 1, j, t);
  3409.    if (i)
  3410.       removeStones0(b, pris, i - 1, j, t);
  3411.    if (j)
  3412.       removeStones0(b, pris, i, j - 1, t);
  3413. }
  3414.  
  3415.  
  3416.  
  3417. void removeStones(b, pris, i, j)
  3418. boardtype b;
  3419. int *pris;
  3420. int i, j;
  3421. {
  3422.    removed = 0;
  3423.    removeStones0(b, pris, i, j, b[i][j]);
  3424.    /* if (removed) boardrefresh(); */
  3425.  
  3426. }
  3427.  
  3428.  
  3429. void removeGroup(i, j)
  3430. int i, j;
  3431. {
  3432.    removeStones(board, prisoners, i, j);
  3433. }
  3434.  
  3435. boolean tryKill(b, pris, i, j, t)
  3436. boardtype b;
  3437. int *pris;
  3438. int i, j;
  3439. piece t;
  3440. {
  3441.    piece w;
  3442.    if (!inRange(i, j))
  3443.       return false;
  3444.    w = b[i][j];
  3445.    if (w != EMPTY && w != t && !alive(b, i, j)) {
  3446.       removeStones(b, pris, i, j);
  3447.       return true;
  3448.    }
  3449.    return false;
  3450. }
  3451.  
  3452. void placeStone(b, pris, i, j, t)
  3453. boardtype b;
  3454. int *pris;
  3455. int i, j;
  3456. piece t;
  3457. {
  3458.    if (inRange(i, j)) {
  3459.       b[i][j] = t;
  3460.       if (j)
  3461.      tryKill(b, pris, i, j - 1, t);
  3462.       if (j < boardsize - 1)
  3463.      tryKill(b, pris, i, j + 1, t);
  3464.       if (i)
  3465.      tryKill(b, pris, i - 1, j, t);
  3466.       if (i < boardsize - 1)
  3467.      tryKill(b, pris, i + 1, j, t);
  3468.    }
  3469. }
  3470.  
  3471.  
  3472.  
  3473.  
  3474. static highlighting = 1;
  3475.  
  3476. makemove(i, j, num, t, btime, bbyo, wtime, wbyo)
  3477. int i, j;
  3478. piece t;
  3479. int btime, bbyo, wtime, wbyo;
  3480. {
  3481.    if (movenum != maxmove) {
  3482.       construct(maxmove);
  3483.    }
  3484.    if (highlighting)
  3485.       unhighlight(lasti, lastj);
  3486.    if (num == 1 && i <= 19)
  3487.       showhcap(0);
  3488.    if (i > 100) {
  3489.       sethandicap(board, i - 100);
  3490.       showhcap(i - 100);
  3491.       moves[num].x = moves[num].y = i;
  3492.       moves[num].col = t;
  3493.       maxmove = movenum = num;
  3494.       if (highlighting)
  3495.      highlight(i, j, num, t, btime, bbyo, wtime, wbyo);
  3496.       return;
  3497.    }
  3498.    if (i == 99) {
  3499.       moves[num].x = moves[num].y = 99;
  3500.       moves[num].col = t;
  3501.       maxmove = movenum = num;
  3502.       if (highlighting) {
  3503.      highlight(i, j, num, t, btime, bbyo, wtime, wbyo);
  3504.      drawpris(prisoners);
  3505.       }
  3506.       return;
  3507.    }
  3508.    placeStone(board, prisoners, i, j, t);
  3509.    if (highlighting)
  3510.       highlight(i, j, num, t, btime, bbyo, wtime, wbyo);
  3511.    if (highlighting)
  3512.       drawpris(prisoners);
  3513.    if (highlighting)
  3514.       drawOneStone(i, j, t);
  3515.    else
  3516.       drawStone(i, j, t);
  3517.    lasti = i;
  3518.    lastj = j;
  3519.    moves[num].x = i;
  3520.    moves[num].y = j;
  3521.    moves[num].col = t;
  3522.    maxmove = movenum = num;
  3523. }
  3524.  
  3525.  
  3526. unmark()
  3527. {
  3528.    unmarkascii(lasti, lastj);
  3529. }
  3530.  
  3531.  
  3532. construct(mov)
  3533. int mov;
  3534. {
  3535.    int i, j;
  3536.    boardtype myboard;
  3537.    int mypris[2];
  3538.  
  3539.    if (mov > maxmove)
  3540.       mov = maxmove;
  3541.    if (mov < 1)
  3542.       mov = 1;
  3543.    clearboard(myboard, mypris);
  3544.    unhighlight(lasti, lastj);
  3545.    dontdraw = 1;
  3546.    for (i = 1; i <= mov; i++) {
  3547.       if (moves[i].x > 100)
  3548.      sethandicap(myboard, moves[i].x - 100);
  3549.       else if (moves[i].x != 99) {
  3550.      placeStone(myboard, mypris, moves[i].x, moves[i].y, moves[i].col);
  3551.      myboard[moves[i].x][moves[i].y] = moves[i].col;
  3552.       }
  3553.    }
  3554.    dontdraw = 0;
  3555.    for (i = 0; i < boardsize; i++)
  3556.       for (j = 0; j < boardsize; j++)
  3557.      if (board[i][j] != myboard[i][j]) {
  3558.         drawStone(i, j, myboard[i][j]);
  3559.         board[i][j] = myboard[i][j];
  3560.      }
  3561.    prisoners[0] = mypris[0];
  3562.    prisoners[1] = mypris[1];
  3563.    highlight(moves[mov].x, moves[mov].y, mov, moves[mov].col,
  3564.          -1, -1, -1, -1);
  3565.    lasti = moves[mov].x;
  3566.    lastj = moves[mov].y;
  3567.    drawpris(prisoners);
  3568.    movenum = mov;
  3569. }
  3570.  
  3571.  
  3572. int savemaxmove = 0, didsave = 0;
  3573.  
  3574.  
  3575. restoremaxmoves()
  3576. {
  3577.    didsave = 0;
  3578.    maxmove = savemaxmove;
  3579. }
  3580.  
  3581. savemaxmoves()
  3582. {
  3583.    if (!didsave) {
  3584.       didsave = 1;
  3585.       savemaxmove = maxmove;
  3586.    }
  3587. }
  3588.  
  3589.  
  3590. showboard(b)
  3591. boardtype b;
  3592. {
  3593.    int i, j;
  3594.    for (i = 0; i < boardsize; i++)
  3595.       for (j = 0; j < boardsize; j++)
  3596.      if (board[i][j] != b[i][j]) {
  3597.         drawStone(i, j, b[i][j]);
  3598.         board[i][j] = b[i][j];
  3599.      }
  3600.    boardrefresh();
  3601. }
  3602.  
  3603.  
  3604. undo()
  3605. {
  3606.    int i, j;
  3607.  
  3608.    maxmove--;
  3609.    if (maxmove)
  3610.       construct(maxmove);
  3611.    else {
  3612.       movenum = 0;
  3613.       unhighlight(lasti, lastj);
  3614.       for (i = 0; i < boardsize; i++)
  3615.      for (j = 0; j < boardsize; j++)
  3616.         if (board[i][j] != EMPTY) {
  3617.            drawStone(i, j, EMPTY);
  3618.            board[i][j] = EMPTY;
  3619.         }
  3620.    }
  3621. }
  3622.  
  3623.  
  3624. int forward(num)
  3625. int num;
  3626. {
  3627.    if (!maxmove)
  3628.       return 1;
  3629.    if (movenum < maxmove)
  3630.       construct(movenum + num);    /* construct() does bounds checking */
  3631.    return 0;
  3632. }
  3633.  
  3634.  
  3635. int backward(num)
  3636. int num;
  3637. {
  3638.    if (!maxmove)
  3639.       return 1;
  3640.    if (movenum > 1)
  3641.       construct(movenum - num);    /* construct() does bounds checking */
  3642.    return 0;
  3643. }
  3644.  
  3645.  
  3646. int beginninggame()
  3647. {
  3648.    if (!maxmove)
  3649.       return 1;
  3650.    construct(1);
  3651.    return 0;
  3652. }
  3653.  
  3654. int endgame()
  3655. {
  3656.    if (!maxmove)
  3657.       return 1;
  3658.    construct(maxmove);
  3659.    return 0;
  3660. }
  3661.  
  3662.  
  3663. int search(i, j)
  3664. int i, j;
  3665. {
  3666.    int k;
  3667.    k = maxmove;
  3668.    while (k > 0 && (moves[k].x != i || moves[k].y != j))
  3669.       k--;
  3670.    if (!k)
  3671.       return 1;
  3672.    construct(k);
  3673.    return 0;
  3674. }
  3675.  
  3676.  
  3677. sethighlight(h)
  3678. int h;
  3679. {
  3680.    highlighting = h;
  3681. }
  3682.  
  3683. #define TOP 0
  3684. #define MID 1
  3685. #define BOT 2
  3686. static int verts[3][26] =
  3687. {
  3688.    {0, 0, 0, 0, 0, 0, 0, 0, 0,
  3689.     2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 3, 0, 0, 0, 4},
  3690.    {0, 0, 0, 0, 0, 0, 0, 0, 0,
  3691.     4, 0, 0, 0, 6, 0, 0, 0, 0, 0, 9, 0, 10, 0, 0, 0, 12},
  3692.    {0, 0, 0, 0, 0, 0, 0, 0, 0,
  3693.     6, 0, 0, 0, 9, 0, 0, 0, 0, 0, 15, 0, 17, 0, 0, 0, 20},
  3694. };
  3695.  
  3696.  
  3697.  
  3698. sethandicap(board, hand)
  3699. boardtype board;
  3700. int hand;
  3701. {
  3702.    /* This is also used to set the handicap.  The 'handi' is the number of
  3703.     * things to set of piece 'p'. */
  3704.  
  3705.    int top, mid, bot;
  3706.    piece t;
  3707.  
  3708.    top = verts[TOP][boardsize];
  3709.    mid = verts[MID][boardsize];
  3710.    bot = verts[BOT][boardsize];
  3711.  
  3712.    /* All of these drop through, '5' checks for odd points. */
  3713.    t = 1;
  3714.    switch (hand) {
  3715.       case 9:            /* taken care of by handi == 5 */
  3716.       case 8:
  3717.      drawStone(mid, top, t);
  3718.      board[mid][top] = t;
  3719.      drawStone(mid, bot, t);
  3720.      board[mid][bot] = t;
  3721.       case 7:            /* taken care of by handi == 5 */
  3722.       case 6:
  3723.      drawStone(bot, mid, t);
  3724.      board[bot][mid] = t;
  3725.      drawStone(top, mid, t);
  3726.      board[top][mid] = t;
  3727.       case 5:
  3728.      if (hand & 0x1) {    /* odd points, test because of drop through */
  3729.         drawStone(mid, mid, t);
  3730.         board[mid][mid] = t;
  3731.      }
  3732.       case 4:
  3733.      drawStone(bot, bot, t);
  3734.      board[bot][bot] = t;
  3735.       case 3:
  3736.      drawStone(top, top, t);
  3737.      board[top][top] = t;
  3738.       case 2:
  3739.      drawStone(bot, top, t);
  3740.      board[bot][top] = t;
  3741.      drawStone(top, bot, t);
  3742.      board[top][bot] = t;
  3743.      break;
  3744.       default:
  3745.      break;
  3746.    }
  3747. }
  3748. SHAR_EOF
  3749. fi
  3750. if test -f 'numbers.h'
  3751. then
  3752.     echo shar: "will not over-write existing file 'numbers.h'"
  3753. else
  3754. cat << \SHAR_EOF > 'numbers.h'
  3755. typedef enum {
  3756.    UNKNOWN = 0,
  3757.    BEEP = 2,            /* \7 telnet          */
  3758.    BOARD = 3,            /* Board being drawn      */
  3759.    DOWN = 4,            /* The server is going down */
  3760.    ERROR = 5,            /* An error reported     */
  3761.    FIL = 6,            /* File being sent     */
  3762.    GAMES = 7,            /* Games listing     */
  3763.    HELP = 8,            /* Help file         */
  3764.    INFO = 9,            /* Generic info         */
  3765.    LAST = 10,            /* Last command         */
  3766.    KIBITZ = 11,            /* Kibitz strings     */
  3767.    LOAD = 12,            /* Loading a game     */
  3768.    LOOK = 13,            /* Look          */
  3769.    MESSAGE = 14,        /* Message lising     */
  3770.    MOVE = 15,            /* Move #:(B) A1     */
  3771.    OBSERVE = 16,        /* Observe report     */
  3772.    PROMPT = 1,            /* A Prompt (never)     */
  3773.    PROVERB = 31,        /* Go Proverb         <=== last value */
  3774.    REFRESH = 17,        /* Refresh of a board     */
  3775.    SAVED = 18,            /* Stored command     */
  3776.    SAY = 19,            /* Say string         */
  3777.    SCORE = 20,            /* Score report         */
  3778.    SHOUT = 21,            /* Shout string         */
  3779.    SHOW = 29,            /* Shout string         */
  3780.    STATUS = 22,            /* Current Game status     */
  3781.    STORED = 23,            /* Stored games         */
  3782.    TELL = 24,            /* Tell string         */
  3783.    THIST = 25,            /* Thist report         */
  3784.    TIM = 26,            /* times command     */
  3785.    TRANSLATE = 30,        /* Translation info     */
  3786.    WHO = 27,            /* who command         */
  3787.    UNDO = 28,            /* Undo report         */
  3788. }  MessageType;
  3789.  
  3790.  
  3791. #define    S_BLACK  '0'
  3792. #define    S_WHITE  '1'
  3793. #define    S_EMPTY  '2'
  3794. #define    S_DAME   '3'
  3795. #define    S_WTERR  '4'
  3796. #define    S_BTERR  '5'
  3797. #define    S_HOSHI  '6'
  3798.  
  3799.  
  3800. typedef enum {
  3801.    LOGON = 0,
  3802.    PASSWORD = 1,
  3803.    PASSWD_NEW = 2,
  3804.    PASSWD_CONFIRM = 3,
  3805.    REGISTER = 4,
  3806.    WAITING = 5,
  3807.    PLAYING = 6,
  3808.    SCORING = 7,
  3809.    OBSERVING = 8,
  3810.    TEACHING = 9
  3811. }  State;
  3812. SHAR_EOF
  3813. fi
  3814. if test -f 'igc.h'
  3815. then
  3816.     echo shar: "will not over-write existing file 'igc.h'"
  3817. else
  3818. cat << \SHAR_EOF > 'igc.h'
  3819.  
  3820. #define MAXGAMES 50
  3821. #define MAXWHO 300
  3822. #define MAXNAME 11
  3823. #define MAXRANK 6
  3824. #define MAXFRIENDS 50
  3825. #define piece char
  3826.  
  3827. #ifdef BCOPY
  3828. #define bcopy(a,b,c) memcpy(b,a,c)
  3829. #endif
  3830.  
  3831. typedef struct {
  3832.    int id;
  3833.  
  3834.    int prompttype;        /* if return is prompt */
  3835.  
  3836.    int x, y;            /* used to report removed stones for scoring */
  3837.  
  3838.  
  3839.    struct {            /* if return is play */
  3840.       int x, y;
  3841.       int movenum;
  3842.       int color;
  3843.    }  moves[400];
  3844.  
  3845.    int movecount;
  3846.    int gamenum;
  3847.    int bcap, btime, bbyo;
  3848.    int wcap, wtime, wbyo;
  3849.  
  3850.    char text[10000];        /* text of message */
  3851.    int lines;            /* number of lines in text */
  3852.  
  3853.    int gamecount;        /* for data from the games command */
  3854.    struct gametype {
  3855.       int gnum;
  3856.       char white[MAXNAME], wrank[MAXRANK], black[MAXNAME], brank[MAXRANK];
  3857.       int mnum, bsize, hcap;
  3858.       float komi;
  3859.       int byo, obcount;
  3860.       char gametext[80];
  3861.    }  gamelist[MAXGAMES];
  3862.    char gamefirst[80];
  3863.  
  3864.  
  3865.    int boardsize, boardline;
  3866.    float wscore, bscore;
  3867.    piece board[19][19];
  3868.    int wnext;            /* white next?  Already have info for black. */
  3869.    char white[MAXNAME], wrank[MAXRANK], black[MAXNAME], brank[MAXRANK];
  3870.    int hcap;
  3871.  
  3872.    int beep;
  3873.  
  3874.    char kibitzer[40];
  3875.    char kibitz[300];
  3876.  
  3877.    int whocount;
  3878.    char *who[MAXWHO];
  3879.    char whodata[MAXWHO][40];
  3880.    char wholast[80];
  3881.    char whofirst[80];
  3882.  
  3883.    float mykomi;
  3884.  
  3885. }  message;
  3886.  
  3887.  
  3888.  
  3889. #define ONSERVER -1
  3890. #define MATCH -2
  3891. #define QUITMESG -3
  3892. #define REMOVE -4
  3893. #define SCOREUNDO -5
  3894. #define TIMEREP -6
  3895. #define TOOMANY -7
  3896. #define CHKOMI -8
  3897. #define STARTSCORE -9
  3898. #define INTRO -10
  3899. #define ENDGAME -11
  3900. #define ENDGAMEINFO -12
  3901.  
  3902. #define BLACK 1
  3903. #define WHITE 2
  3904. #define EMPTY 0
  3905. #define DAME 3
  3906. #define BTERR 4
  3907. #define WTERR 5
  3908.  
  3909. #define KEY -33
  3910. SHAR_EOF
  3911. fi
  3912. if test -f 'Makefile'
  3913. then
  3914.     echo shar: "will not over-write existing file 'Makefile'"
  3915. else
  3916. cat << \SHAR_EOF > 'Makefile'
  3917. CC = cc 
  3918.  
  3919. # if you get strstr undefined, add -DSTRSTR to the DEFINES line below
  3920. # if you get bcopy undefined, add -DBCOPY 
  3921. # if you get strtol undefined, add -DSTRTOL
  3922.  
  3923. # if you change something in the Makefile, you may need to 
  3924. # type rm *.o before trying to recompile.
  3925.  
  3926. # The -DDEBUG below causes igc to create dump?.igc files which 
  3927. # contain logs of each IGS session.  Remove the -DDEBUG
  3928. # to suppress creation of the dump files.  I may request 
  3929. # the log files from you if you report bugs.
  3930.  
  3931. DEFINES = -DDEBUG 
  3932.  
  3933. # You may want to change -g (include debug information) into
  3934. # -O for optimize.  If you do this, also run strip on the 
  3935. # igc file:  'strip igc'.  This will make the executable
  3936. # even smaller.
  3937.  
  3938. CFLAGS = -g  $(DEFINES) 
  3939.  
  3940. LIBS =     -lcurses -ltermlib
  3941.  
  3942. # link line for PTX.  System V systems need something like this:
  3943. #LIBS = -lcurses -ltermlib -lsocket -linet -lnsl 
  3944.  
  3945. # Under Irix running Yellow Pages, add -lsun to the link line
  3946.  
  3947. # Under RS/6000 AIX 3.1, remove the -ltermlib 
  3948.  
  3949. PROGRAM = igc
  3950.  
  3951. MAN = igc.doc
  3952.  
  3953. OBJ = socket.o igc.o parse.o ascii.o board.o
  3954.  
  3955. SRC = socket.c igc.c parse.c ascii.c board.c
  3956.  
  3957. HDRS =    numbers.h igc.h
  3958.  
  3959. FILES = README $(SRC) $(HDRS) Makefile igc.6 BUGS
  3960.  
  3961. all: $(PROGRAM) $(MAN)
  3962.  
  3963. $(PROGRAM): $(OBJ)
  3964.     @echo Loading...
  3965.     @$(CC) $(OBJ) $(LIBS) -o $(PROGRAM)
  3966.  
  3967. $(MAN): igc.6
  3968.     nroff -man igc.6 > $(MAN)
  3969.  
  3970. $(OBJ): $(HDRS)
  3971.  
  3972. shar: 
  3973.     @shar $(FILES) > $(PROGRAM).shar
  3974.  
  3975. shar2: 
  3976.     @shar -m 200000 -f $(PROGRAM) $(FILES) 
  3977.  
  3978. lint:
  3979.     lint $(SRC) -lcurses > lintout
  3980.  
  3981.  
  3982.  
  3983.  
  3984.  
  3985.  
  3986.  
  3987.  
  3988. SHAR_EOF
  3989. fi
  3990. if test -f 'igc.6'
  3991. then
  3992.     echo shar: "will not over-write existing file 'igc.6'"
  3993. else
  3994. cat << \SHAR_EOF > 'igc.6'
  3995. .TH IGC 6   "7 June 1993"
  3996. .SH NAME
  3997. igc - ascii client to Internet Go Server
  3998. .SH SYNOPSIS
  3999. .B igc
  4000. [\-s] [host [port]]
  4001. .SH DESCRIPTION
  4002. Go is an ancient asian strategy game based on the capture of
  4003. territory.
  4004. Players alternate, placing stones on the board and trying to surround
  4005. as many empty intersections as possible.  The 
  4006. .B Internet Go Server
  4007. allows players to meet and play interactive games.  
  4008. .B Igc
  4009. provides a more convenient interface for connections to the 
  4010. .B Internet Go Server.
  4011. .SH COMMAND LINE OPTIONS
  4012. .TP 8
  4013. .B \-s
  4014. Supresses autologin.
  4015. .LP
  4016. .TP 8
  4017. .B [host [port]]
  4018. Connects to specified host and port number.  The host can be specified
  4019. as a fully qualified hostname, or as an abbreviation.  If the
  4020. abbreviation is used, then the port number cannot be included.  
  4021. The shorthand names supported by default are:
  4022. .in +2m
  4023. .ta
  4024. .ta 7m +\w'mmmmmmm\ \ 'u +\w'hellspark.wharton.upenn.edu\ \ 'u +
  4025. .nf
  4026.  
  4027.     name    host address    port
  4028. site 0    icsi    hellspark.wharton.upenn.edu    6969
  4029. site 1    pasteur    ftp.pasteur.fr    6969
  4030.  
  4031. .fi
  4032. .in -2m
  4033. If no host is specified, then site 0 is used.  To connect to the French
  4034. site, for example, 
  4035. use 'igc pasteur'.  
  4036. (See the customization section for more information.)
  4037. .SH OPERATION
  4038. When 
  4039. .B igc 
  4040. is run, it opens a connection to the go server.  Unlike a straight
  4041. telnet connection, 
  4042. .B igc
  4043. does not print the '#>' prompt, and your normal suspend key (usually
  4044. ^Z) will suspend the client.  If you use telnet after using 
  4045. .B igc
  4046. the prompts from the server will be different because the server is in
  4047. client mode.  Log in with username and password at the numeric
  4048. prompts and then type 'toggle client' to get the normal prompts.
  4049. .LP
  4050. Initially, 
  4051. .B igc
  4052. acts as a direct connection to the server.  When a game is displayed,
  4053. the screen will be split into two windows:  one for the board on the
  4054. left, and one
  4055. for text interaction with the server on the right.  The 
  4056. ESC key will switch between
  4057. the two windows, and the ^L key will redraw the display (from either
  4058. window).  
  4059. .LP
  4060. When the server sends long messages such as the output from 
  4061. the 'games' command, the 'who' command, or the 'help' commmand, it
  4062. prints the message on top of the board.  Press any key to restore the
  4063. board.  If the message is longer than 22 lines, then the message will
  4064. be displayed in chunks.  
  4065. .LP
  4066. The names of the players appear above the board, followed by their
  4067. ranks, and the time remaining.  An arrow indicates whose turn
  4068. it is.  You can view only one game
  4069. at a time (either by observing, or by playing).  The number of 
  4070. that game is displayed to the left of the Black's name.
  4071. This number should be '--' if
  4072. you are not playing or observing a game.  To the right of Black's
  4073. name, above the right corner of the board (in 19x19 games),
  4074. is the number of handicap
  4075. stones.  This region is blank if the game is even. 
  4076. To the right of white's name is the komi for the game.  
  4077. Below the board, a line shows the number and coordinates of the last
  4078. move, and the captured stones are displayed.  The display shows the
  4079. number of black stones which were captured, followed by the
  4080. number of white stones captured.  
  4081. .LP
  4082. All of the commands which are active from the board window are single
  4083. keystroke commands.  The cursor can be moved around the board using
  4084. either the number keys (12346789), the emacs keys (^P ^N ^B ^F) or the
  4085. rogue keys (hjklyubn).  The board keeps track of all moves received so
  4086. that you can view the history of the game.  Note that the 
  4087. server's 'look' and 'status' commands do not generate a move history. 
  4088. When these commands are used, or when a game is scored, a snapshot of
  4089. the board is obtained from the server and temporarily placed on top of
  4090. the board.  The receipt of a move, or any attempt to move through the
  4091. game record, will restore the previous display.  When the status
  4092. display is active, the game number area in the upper right corner of
  4093. the screen reads "sta".  The previous display can be restored by the
  4094. client command 'restore'.
  4095. .LP
  4096. .TP 8
  4097. 0, space, return
  4098. Makes a move on the board.  (Send the coordinates of the cursor to the
  4099. server.)
  4100. .LP
  4101. .TP 8
  4102. c
  4103. Clears the marks on the board which indicate which piece was played
  4104. last.  
  4105. .LP
  4106. .TP 8
  4107. ^
  4108. Clears the server window to the right of the board.
  4109. .LP
  4110. .TP 8
  4111. comma, period (, and .)
  4112. Move backwards (comma) or forwards (period) through the moves in the
  4113. game currently displayed on the board.  If a new move arrives while you
  4114. are observing the game like this, you will be bounced back to the end
  4115. of the game.  
  4116. .LP
  4117. .TP 8
  4118. <, >
  4119. Move backwards or forwards by sets of ten moves
  4120. through the game currently displayed on the board.  
  4121. .LP
  4122. .TP 8
  4123. s, e
  4124. Jump to start (s) or end (e) of the game displayed on the board.
  4125. .LP
  4126. .TP 8
  4127. f, /
  4128. Find the time in the game when a stone was played at the current
  4129. cursor location, and jump to that move.  If a stone was played on one
  4130. point several times, this command jumps to the latest. 
  4131. .LP
  4132. Commands in the server window are words rather than single characters.
  4133. These commands will work in the full screen mode as well when appropriate.
  4134. The backspace and delete keys will remove the last character you
  4135. typed, and ^U will kill the whole line.  
  4136. .LP
  4137. .TP 4
  4138. helpigc 
  4139. Display a brief help screen.
  4140. .LP
  4141. .TP 4
  4142. observe <n>
  4143. Begin observing game n.  If you are already observing a game, this
  4144. command will stop observing that game and begin observing game n.
  4145. If you are observing game n, then this command will stop observing
  4146. game n.  This command can be abbreviated as 'ob'. 
  4147. .LP
  4148. .TP 4
  4149. unobserve
  4150. Stop observing the game you are watching.  This command can be
  4151. abbreviated as 'unob'.  
  4152. .LP
  4153. .TP 4
  4154. peek <n>
  4155. Peeks at game n.  Fetches all the moves from that game without
  4156. observing so that you can play the game back from the start, or just
  4157. see what it looks like.
  4158. .LP
  4159. .TP 4
  4160. restore
  4161. Restores the active game display which was on the board before
  4162. a 'look' or 'status' command.  This command is only valid when the
  4163. upper left corner of the screen says "sta". 
  4164. .LP
  4165. .TP 4
  4166. goto <n>
  4167. Goes to move n in the game displayed on the board.
  4168. .LP
  4169. .TP 4
  4170. clear
  4171. Clears the server window
  4172. .LP
  4173. .TP 4
  4174. noboard
  4175. Removes the board and returns to full screen interaction with the
  4176. server.
  4177. .LP
  4178. .TP 4
  4179. user <name>
  4180. Prints the line for <name> from the output of the last who command.
  4181. .LP
  4182. .TP 4
  4183. sort <sort-type>
  4184. Sets the sorting method for output from the server's 'who' command. 
  4185. Available sorting methods are: none, rank, rating, name, and game.  The 'none'
  4186. type does no sorting.  The 'name' type sorts by name, 'rank' sorts by
  4187. rank, 'rating' sorts by ranks, but distinguishes between stated ranks
  4188. and computed ones, 'idle' sorts by idle time and 'game' sorts first by 
  4189. the game a player is playing in,
  4190. second by whether a player is open for games, and finally by rank.  
  4191. The default sorting method is 'name'. 
  4192. .LP
  4193. .TP 4
  4194. gamessort <games-sort-type>
  4195. Sets the sorting method for output from the server's 'games' command.
  4196. Available sorting methods are: none, number, obcount.  The 'number' type
  4197. sorts by game number and is the default.  The 'obcount' type sorts
  4198. by the number of observers watching each game.  
  4199. .LP
  4200. .TP 4
  4201. filter 
  4202. Enable filtering of shout commands for friends.  (See 'friend' command.)
  4203. .LP
  4204. .TP 4
  4205. nofilter
  4206. Disable filtering of shout commands for friends.  (See 'friend' command.)
  4207. .LP
  4208. .TP 4
  4209. friend [name]
  4210. If the name is given, add that name to the list of friends.  If no
  4211. name is given, then print the current list of friends.  When filtering
  4212. is enabled, only shout commands which start with a name on the friends
  4213. list will be printed.  The friends list is limited to 50 names.
  4214. .LP
  4215. .TP 4
  4216. unfriend name
  4217. Remove the specified name from the friends list.
  4218. .LP
  4219. .TP 4
  4220. inverse
  4221. Switch board display to inverse video.  (This is the default display).
  4222. .LP
  4223. .TP 4
  4224. noinverse
  4225. Switch board display to regular video.
  4226. .LP
  4227. .TP 4
  4228. invedge
  4229. Display edges with inverse video.
  4230. .LP
  4231. .TP 4
  4232. noinvedge
  4233. Display edges with normal video. (This is the default).
  4234. .LP
  4235. .TP 4
  4236. chars <list>
  4237. Sets the board characters.  The order is
  4238. empty, black, white, dame, black territory, white territory, hoshi
  4239. point, border.  The characters should appear without spaces betwee
  4240. them.  The default character set is .#O?+-+ with a space for the
  4241. border character.
  4242. .LP
  4243. .TP 4
  4244. border <char>
  4245. Sets the border character to char.  If char is omitted then the border
  4246. is turned off.  (This is the default.)
  4247. .LP
  4248. .TP 4
  4249. beeps <n>
  4250. Sets the number of beeps sent when sending a beep.  The
  4251. default is one.
  4252. .LP
  4253. .TP 4
  4254. saybeep
  4255. Causes 
  4256. .B igc
  4257. to beep when your opponent says something to you during a game using
  4258. the say command.  Does not cause
  4259. messages sent with the tell command to beep.
  4260. .LP
  4261. .TP 4
  4262. nosaybeep
  4263. Do not beep when your opponent says something to you with the say
  4264. command.  (This is the default.)
  4265. .LP
  4266. .TP 4
  4267. tellbeep
  4268. Causes
  4269. .B igc
  4270. to beep if anyone tells you anything at any time.  
  4271. Does not cause messages sent with the say command to beep.
  4272. .LP
  4273. .TP 4
  4274. notellbeep
  4275. Do not beep when people tell things to you.  (This is the default.)
  4276. .LP
  4277. .TP 4
  4278. prefix <text>
  4279. Adds text to every line you type to the server.  All characters before
  4280. your text will be used in the prefix.  The purpose of this command is
  4281. to make it easier to hold conversations with someone. 
  4282. To talk with goplayer, you might type 'prefix tell goplayer ' (note
  4283. the extra space).  All subsequent lines would be sent to goplayer.
  4284. If you start a line with '!' then the prefix will not be used. 
  4285. To turn off the prefix, type '!prefix'. 
  4286. When the prefix is active and the board is displayed, the prefix text
  4287. is displayed at the bottom of the server window.
  4288. .LP
  4289. .TP 4
  4290. edgemarks
  4291. Turns on display of marks at the edge of the board to indicate last
  4292. move.
  4293. .LP
  4294. .TP 4
  4295. noedgemarks
  4296. Turns off display of marks at the edge of the board to indicate last
  4297. move. (This is the default.)
  4298. .LP
  4299. .TP 4
  4300. piecemarks
  4301. Turns on display of marks around the last stone played.  (This is
  4302. the default.)
  4303. .LP
  4304. .TP 4
  4305. nopiecemarks
  4306. Turns off display of marks around the last stone played.
  4307. .SH CUSTOMIZATION
  4308. The file 
  4309. .B .igcrc
  4310. is used to do initialization.  You do not need to have this file, but
  4311. it can set up 
  4312. .B igc
  4313. to suit your desires and it can automatically log you in.
  4314. You create this file in your home directory yourself, using 
  4315. a text editor (emacs, vi).  
  4316. The following server window commands are supported in the 
  4317. .B .igcrc
  4318. file: inverse, noinverse, invedge, noinvedge, beeps, saybeep, 
  4319. nosaybeep, chars, border, sort, gamessort, friend, unfriend, filter, 
  4320. nofilter.  
  4321. They can be used to configure the display as desired.
  4322. .LP
  4323. Some special commands are supported as well:
  4324. .LP
  4325. .TP 4
  4326. nointro
  4327. Supresses the display of the login message which is printed before
  4328. you login. 
  4329. .LP
  4330. .TP 4
  4331. login <name>
  4332. Causes 
  4333. .B igc
  4334. to automatically send <name> as your login name when the connection is
  4335. established.  (This is suppressed by the \-s option.)
  4336. .LP
  4337. .TP 4
  4338. password <password>
  4339. Causes 
  4340. .B igc
  4341. to send <password> as your password.  If you use this command, you
  4342. should make sure that your 
  4343. .B .igcrc
  4344. file is not world readable.  Use the command 'chmod 600 .igcrc' to 
  4345. set the insure that this file is not world readable.
  4346. (Transmission of <password> is supressed by the \-s option.)
  4347. .LP
  4348. .TP 4
  4349. site <number> <name> <address> <port>
  4350. The program keeps a table of ten sites labeled site 0 through site 9.
  4351. By specifying the desired <number>, you can define new servers.
  4352. A server has <name> as its shorthand
  4353. reference, <address> as a fully qualified internet address, and port
  4354. number <port>.  By changing site 0, you can change the default site
  4355. which is used if
  4356. .B igc
  4357. is invoked without parameters.  By default, the first two sites are
  4358. set as described under command line options.  The remaining eight
  4359. sites are undefined.  
  4360. .SH BUGS
  4361. .LP
  4362. The server allows command abbreviation, but the client does not. 
  4363. .LP
  4364. The server doesn't correctly mark the ends of games, so if a game
  4365. ends while you are playing/observing, the client may still think
  4366. you are playing/observing.  The number in the upper left will
  4367. say '--' if the client realizes you are not doing anything.  If
  4368. it doesn't, press return a few times in the server window.
  4369. .LP
  4370. If someone who is playing a game changes their rank, the change
  4371. will not be reflected on the screens of other people watching or
  4372. playing that game.  
  4373. .LP
  4374. If komi changes during a game, the observers will not see the change.
  4375. (The players will.)
  4376. .LP
  4377. The program cannot handle boards larger than 19x19.
  4378. .SH AUTHOR
  4379. Adrian Mariano (adrian@u.washington.edu, adrian on IGS)
  4380. .SH SEE ALSO
  4381. LaTeX and Postscript documentation for the IGS is available on
  4382. ftp.u.washington.edu in public/go/prog/igs.tex.Z and public/go/prog/igs.ps.Z.  
  4383. .LP
  4384. Other programs: mgt, pcigc, stigc, xigc, xgospel
  4385.  
  4386. SHAR_EOF
  4387. fi
  4388. if test -f 'BUGS'
  4389. then
  4390.     echo shar: "will not over-write existing file 'BUGS'"
  4391. else
  4392. cat << \SHAR_EOF > 'BUGS'
  4393. can't load selfgames
  4394. doesn't intercept partial commands
  4395. SHAR_EOF
  4396. fi
  4397. exit 0
  4398. #    End of shell archive
  4399.